[ci] Add OPENAI_API_KEY check to Codex steps

Add early exit checks to Codex steps so they skip gracefully when OPENAI_API_KEY is not configured, instead of failing with exit code 1. This prevents noise from Codex workflows when the API key is not set up.
[ci] Fix invalid secrets reference in workflow conditions
2026-11-08 11:55:21 -05:00 · 2026-05-01 15:22:17 -07:00 · 2026-05-01 15:21:42 -07:00 · 2026-05-01 14:10:57 -07:00 · 2026-05-01 13:32:27 -07:00 · 2026-04-27 18:13:43 -07:00
456 changed files with 11211 additions and 75139 deletions
@@ -0,0 +1,9 @@
+name: install-jdk8-on-macos
+runs:
+  using: composite
+  steps:
+  - name: Install JDK 8 on macos
+    run: |-
+      HOMEBREW_NO_AUTO_UPDATE=1 brew tap bell-sw/liberica
+      HOMEBREW_NO_AUTO_UPDATE=1 brew install --cask liberica-jdk8
+    shell: bash
@@ -2,13 +2,6 @@ name: pre-steps
 runs:
  using: composite
  steps:
-  - name: Dump ulimits for diagnostics
-    run: |
-      echo "=== ulimits (soft) ==="
-      ulimit -a -S || true
-      echo "=== ulimits (hard) ==="
-      ulimit -a -H || true
-    shell: bash
  - name: Install lld linker for faster builds
    run: apt-get update -y && apt-get install -y lld 2>/dev/null || true
    shell: bash
@@ -1,17 +0,0 @@
-name: setup-jdk-on-macos
-runs:
-  using: composite
-  steps:
-  - name: Set up JDK on macos
-    run: |-
-      set -euo pipefail
-
-      JAVA_HOME="$(/usr/libexec/java_home -v 21)"
-
-      echo "JAVA_HOME=${JAVA_HOME}" >> "$GITHUB_ENV"
-      echo "JAVAC_ARGS=--release 8" >> "$GITHUB_ENV"
-      echo "${JAVA_HOME}/bin" >> "$GITHUB_PATH"
-      echo "Using JDK at ${JAVA_HOME}"
-      "${JAVA_HOME}/bin/java" -version
-      "${JAVA_HOME}/bin/javac" -version
-    shell: bash
@@ -3,7 +3,7 @@ inputs:
  suite-run:
    description: Comma-separated list of test suites to run (empty to skip C++ tests)
    required: false
-    default: arena_test,db_basic_test,db_test,db_etc2_test,db_merge_operand_test,bloom_test,c_test,coding_test,crc32c_test,dynamic_bloom_test,env_basic_test,env_test,hash_test,random_test
+    default: arena_test,db_basic_test,db_test,db_test2,db_merge_operand_test,bloom_test,c_test,coding_test,crc32c_test,dynamic_bloom_test,env_basic_test,env_test,hash_test,random_test
  run-java:
    description: Whether to run Java tests
    required: false
@@ -11,49 +11,8 @@ inputs:
 runs:
  using: composite
  steps:
-  - name: Detect Visual Studio generator
-    id: detect_vs
-    shell: pwsh
-    run: |
-      $ErrorActionPreference = "Stop"
-
-      $vswhere = Join-Path ([Environment]::GetFolderPath("ProgramFilesX86")) "Microsoft Visual Studio\Installer\vswhere.exe"
-      if (!(Test-Path $vswhere)) {
-        throw "vswhere.exe was not found at $vswhere"
-      }
-
-      $vsInstallationsJson = & $vswhere -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -format json -utf8
-      $vsInstallations = @($vsInstallationsJson | ConvertFrom-Json)
-      if ($vsInstallations.Count -eq 0) {
-        throw "No Visual Studio instance with C++ tools was found."
-      }
-
-      $vsInstallation = $vsInstallations[0]
-      $vsMajor = [int]$vsInstallation.catalog.productLineVersion
-      if ($vsMajor -eq 0) {
-        $vsMajor = [int]($vsInstallation.installationVersion.Split(".")[0])
-      }
-
-      $generatorLine = cmake --help | Where-Object {
-        $_ -match "^\*?\s*Visual Studio $vsMajor\s+\d{4}\s*="
-      } | Select-Object -First 1
-      if (!$generatorLine) {
-        throw "CMake does not support a Visual Studio generator for VS major version $vsMajor."
-      }
-
-      $cmakeGenerator = ($generatorLine -replace "^\*?\s*", "" -replace "\s*=.*$", "").Trim()
-      $vsVersionRange = "[{0}.0,{1}.0)" -f $vsMajor, ($vsMajor + 1)
-
-      echo "Detected Visual Studio at $($vsInstallation.installationPath)"
-      echo "Using CMake generator: $cmakeGenerator"
-      echo "Using setup-msbuild vs-version: $vsVersionRange"
-
-      "CMAKE_GENERATOR=$cmakeGenerator" >> $env:GITHUB_ENV
-      "vs_version=$vsVersionRange" >> $env:GITHUB_OUTPUT
  - name: Add msbuild to PATH
-    uses: microsoft/setup-msbuild@v2
-    with:
-      vs-version: ${{ steps.detect_vs.outputs.vs_version }}
+    uses: microsoft/setup-msbuild@v1.3.1
  - name: ccache
    uses: hendrikmuhs/ccache-action@v1.2
    with:
@@ -73,23 +32,15 @@ runs:
      CMAKE_HOME: C:/Program Files/CMake
      CMAKE_BIN: C:/Program Files/CMake/bin/cmake.exe
      CTEST_BIN: C:/Program Files/CMake/bin/ctest.exe
+      JAVA_HOME: C:/Program Files/BellSoft/LibericaJDK-8
      SNAPPY_HOME: ${{ github.workspace }}/thirdparty/snappy-1.2.2
      SNAPPY_INCLUDE: ${{ github.workspace }}/thirdparty/snappy-1.2.2;${{ github.workspace }}/thirdparty/snappy-1.2.2/build
      SNAPPY_LIB_DEBUG: ${{ github.workspace }}/thirdparty/snappy-1.2.2/build/Debug/snappy.lib
    run: |-
      # NOTE: if ... Exit $LASTEXITCODE lines needed to exit and report failure
      echo ===================== Install Dependencies =====================
-      if (!$env:JAVA_HOME -or !(Test-Path (Join-Path $env:JAVA_HOME "bin\javac.exe"))) {
-        $javac = Get-Command javac -ErrorAction SilentlyContinue
-        if (!$javac) {
-          Write-Error "javac was not found on PATH and JAVA_HOME is not set."
-          Exit 1
-        }
-        $env:JAVA_HOME = Split-Path (Split-Path $javac.Source -Parent) -Parent
-      }
-      echo "JAVA_HOME=$env:JAVA_HOME"
-      & "$env:JAVA_HOME\bin\java.exe" -version
-      & "$env:JAVA_HOME\bin\javac.exe" -version
+      choco install liberica8jdk -y
+      if(!$?) { Exit $LASTEXITCODE }
      mkdir $Env:THIRDPARTY_HOME
      cd $Env:THIRDPARTY_HOME
      echo "Building Snappy dependency..."
@@ -102,11 +53,11 @@ runs:
      cd build
      & cmake -G "$Env:CMAKE_GENERATOR" .. -DSNAPPY_BUILD_TESTS=OFF -DSNAPPY_BUILD_BENCHMARKS=OFF
      if(!$?) { Exit $LASTEXITCODE }
-      cmake --build . --config Debug --parallel 32 -- /p:Platform=x64
+      msbuild Snappy.sln -maxCpuCount -property:Configuration=Debug -property:Platform=x64
      if(!$?) { Exit $LASTEXITCODE }
      echo ======================== Build RocksDB =========================
      cd ${{ github.workspace }}
-      $env:Path = "$env:JAVA_HOME\bin;" + $env:Path
+      $env:Path = $env:JAVA_HOME + ";" + $env:Path
      mkdir build
      cd build
      & cmake -G "$Env:CMAKE_GENERATOR" -DCMAKE_BUILD_TYPE=Debug -DWIN_CI=1 -DPORTABLE="$Env:CMAKE_PORTABLE" -DSNAPPY=1 -DXPRESS=1 -DJNI=1 ..
@@ -114,7 +65,7 @@ runs:
      cd ..
      echo "Building with VS version: $Env:CMAKE_GENERATOR"
      # use more parallel processes than the number of processes available, as most of the compile command would be cache hit
-      cmake --build build --config Debug --parallel 32 -- /p:LinkIncremental=false /p:Platform=x64
+      msbuild build/rocksdb.sln /m:32 /p:LinkIncremental=false -property:Configuration=Debug -property:Platform=x64
      if(!$?) { Exit $LASTEXITCODE }
      echo ========================= Test RocksDB =========================
      $suiteRun = "${{ inputs.suite-run }}"
@@ -531,9 +531,7 @@ jobs:
              core.warning(
                `Could not parse classifier output: ${error.message}`);
            }
-            // Keep Claude's thinking budget below the action's effective
-            // max_tokens so the API has room for the final review text.
-            const budget = label === 'simple' ? '16000' : '24000';
+            const budget = label === 'simple' ? '16000' : '32000';
            core.info(
              `Complexity classified as: ${label} ` +
              `-> MAX_THINKING_TOKENS=${budget}`
@@ -553,28 +551,15 @@ jobs:
        run: |
          if [ -z "${OPENAI_API_KEY}" ]; then
            echo "OPENAI_API_KEY not configured, skipping Codex review"
-            printf 'complex\n' > codex-complexity-output.txt
            exit 0
          fi
          mkdir -p "${CODEX_HOME}"
-          set +e
          codex exec \
            -m "${CODEX_MODEL}" \
            -c model_reasoning_effort="medium" \
            --dangerously-bypass-approvals-and-sandbox \
            --output-last-message codex-complexity-output.txt \
            - < /tmp/complexity_prompt.txt > codex-complexity.log 2>&1
-          exit_code=$?
-          set -e
-          if [ "${exit_code}" -ne 0 ]; then
-            echo "Codex complexity classification failed with exit code ${exit_code}"
-            echo "Defaulting to complex review budget"
-            if [ -s codex-complexity.log ]; then
-              echo "Last 100 lines of codex-complexity.log:"
-              tail -100 codex-complexity.log
-            fi
-            printf 'complex\n' > codex-complexity-output.txt
-          fi

      - name: Pick thinking budget (Codex)
        if: >-
@@ -714,6 +699,8 @@ jobs:
          CODEX_HOME: /tmp/codex-home
          CODEX_MODEL: ${{ inputs.default_model }}
          CODEX_REASONING_EFFORT: ${{ steps.budget_codex.outputs.effort }}
+          BASE_SHA: ${{ steps.pr_info.outputs.base_sha }}
+          PR_TITLE: ${{ steps.pr_info.outputs.pr_title }}
        run: |
          if [ -z "${OPENAI_API_KEY}" ]; then
            echo "OPENAI_API_KEY not configured, skipping Codex review"
@@ -721,7 +708,9 @@ jobs:
          fi
          mkdir -p "${CODEX_HOME}"
          set +e
-          codex exec \
+          codex exec review \
+            --base "${BASE_SHA}" \
+            --title "${PR_TITLE}" \
            -m "${CODEX_MODEL}" \
            -c model_reasoning_effort="${CODEX_REASONING_EFFORT}" \
            --dangerously-bypass-approvals-and-sandbox \
@@ -1113,19 +1102,9 @@ jobs:
            }
            const override = (process.env.OVERRIDE || '').trim();
            if (override && /^\d+$/.test(override)) {
-              const maxSafeBudget = 24000;
-              const requested = parseInt(override, 10);
-              const budget = Math.min(requested, maxSafeBudget).toString();
-              if (budget !== override) {
-                core.info(
-                  `Clamping thinking_budget override from ${override} ` +
-                  `to ${budget} so max_tokens can exceed thinking tokens.`
-                );
-              } else {
-                core.info(`Using thinking_budget override: ${budget}`);
-              }
+              core.info(`Using thinking_budget override: ${override}`);
              core.setOutput('label', 'override');
-              core.setOutput('tokens', budget);
+              core.setOutput('tokens', override);
              return;
            }
            let label = 'complex';
@@ -1143,9 +1122,7 @@ jobs:
              core.warning(
                `Could not parse classifier output: ${error.message}`);
            }
-            // Keep Claude's thinking budget below the action's effective
-            // max_tokens so the API has room for the final review text.
-            const budget = label === 'simple' ? '16000' : '24000';
+            const budget = label === 'simple' ? '16000' : '32000';
            core.info(
              `Complexity classified as: ${label} ` +
              `-> MAX_THINKING_TOKENS=${budget}`
@@ -1163,30 +1140,13 @@ jobs:
          CODEX_HOME: /tmp/codex-home
          CODEX_MODEL: ${{ inputs.selected_model != '' && inputs.selected_model || inputs.default_model }}
        run: |
-          if [ -z "${OPENAI_API_KEY}" ]; then
-            echo "OPENAI_API_KEY not configured, skipping Codex review"
-            printf 'complex\n' > codex-complexity-output.txt
-            exit 0
-          fi
          mkdir -p "${CODEX_HOME}"
-          set +e
          codex exec \
            -m "${CODEX_MODEL}" \
            -c model_reasoning_effort="medium" \
            --dangerously-bypass-approvals-and-sandbox \
            --output-last-message codex-complexity-output.txt \
            - < /tmp/complexity_prompt.txt > codex-complexity.log 2>&1
-          exit_code=$?
-          set -e
-          if [ "${exit_code}" -ne 0 ]; then
-            echo "Codex complexity classification failed with exit code ${exit_code}"
-            echo "Defaulting to complex review budget"
-            if [ -s codex-complexity.log ]; then
-              echo "Last 100 lines of codex-complexity.log:"
-              tail -100 codex-complexity.log
-            fi
-            printf 'complex\n' > codex-complexity-output.txt
-          fi

      - name: Pick thinking budget (Codex)
        if: steps.request.outputs.skip != 'true' && inputs.provider == 'codex'
@@ -1336,6 +1296,8 @@ jobs:
          CODEX_HOME: /tmp/codex-home
          CODEX_MODEL: ${{ inputs.selected_model != '' && inputs.selected_model || inputs.default_model }}
          CODEX_REASONING_EFFORT: ${{ steps.manual_budget_codex.outputs.effort }}
+          BASE_SHA: ${{ steps.pr_info.outputs.base_sha }}
+          PR_TITLE: ${{ steps.pr_info.outputs.pr_title }}
          COMMAND_TYPE: ${{ steps.request.outputs.type }}
        run: |
          mkdir -p "${CODEX_HOME}"
@@ -1348,7 +1310,9 @@ jobs:
              --output-last-message codex-review-output.md \
              - < /tmp/prompt.txt > codex-review-execution.log 2>&1
          else
-            codex exec \
+            codex exec review \
+              --base "${BASE_SHA}" \
+              --title "${PR_TITLE}" \
              -m "${CODEX_MODEL}" \
              -c model_reasoning_effort="${CODEX_REASONING_EFFORT}" \
              --dangerously-bypass-approvals-and-sandbox \
@@ -40,7 +40,6 @@ jobs:
          name: ${{ inputs.result_artifact_name }}
          run-id: ${{ github.event.workflow_run.id }}
          github-token: ${{ secrets.GITHUB_TOKEN }}
-          path: _artifact
        continue-on-error: true

      - name: Post or update PR comment
@@ -53,18 +52,8 @@ jobs:
        with:
          script: |
            const fs = require('fs');
-            const path = require('path');
-            const artifactDir = '_artifact';
-            const commentFile = path.join(
-              artifactDir,
-              process.env.COMMENT_FILE
-            );
-            const prNumberFile = path.join(artifactDir, 'pr_number.txt');
-            const triggerTypeFile = path.join(artifactDir, 'trigger_type.txt');
-            const headShaFile = path.join(artifactDir, 'head_sha.txt');
-
-            if (!fs.existsSync(commentFile) ||
-                !fs.existsSync(prNumberFile)) {
+            if (!fs.existsSync(process.env.COMMENT_FILE) ||
+                !fs.existsSync('pr_number.txt')) {
              core.info('No review results found; skipping.');
              return;
            }
@@ -72,16 +61,16 @@ jobs:
            const post = require('./.github/scripts/post-pr-comment.js');
            const provider = process.env.PROVIDER;
            const providerTitle = provider === 'codex' ? 'Codex' : 'Claude';
-            const body = fs.readFileSync(commentFile, 'utf8');
+            const body = fs.readFileSync(process.env.COMMENT_FILE, 'utf8');
            const prNumber = parseInt(
-              fs.readFileSync(prNumberFile, 'utf8').trim(),
+              fs.readFileSync('pr_number.txt', 'utf8').trim(),
              10
            );
-            const trigger = fs.existsSync(triggerTypeFile) ?
-              fs.readFileSync(triggerTypeFile, 'utf8').trim() :
+            const trigger = fs.existsSync('trigger_type.txt') ?
+              fs.readFileSync('trigger_type.txt', 'utf8').trim() :
              'auto';
-            const headSha = fs.existsSync(headShaFile) ?
-              fs.readFileSync(headShaFile, 'utf8').trim() :
+            const headSha = fs.existsSync('head_sha.txt') ?
+              fs.readFileSync('head_sha.txt', 'utf8').trim() :
              '';
            const shortSha = headSha ? headSha.substring(0, 7) : '';
            const runId = process.env.RUN_ID;
@@ -130,16 +119,12 @@ jobs:
        with:
          script: |
            const fs = require('fs');
-            const path = require('path');
-            const artifactDir = '_artifact';
-            const triggerTypeFile = path.join(artifactDir, 'trigger_type.txt');
-            const commentIdFile = path.join(artifactDir, 'comment_id.txt');
-            if (!fs.existsSync(triggerTypeFile)) return;
-            const trigger = fs.readFileSync(triggerTypeFile, 'utf8').trim();
+            if (!fs.existsSync('trigger_type.txt')) return;
+            const trigger = fs.readFileSync('trigger_type.txt', 'utf8').trim();
            if (trigger !== 'manual') return;
-            if (!fs.existsSync(commentIdFile)) return;
+            if (!fs.existsSync('comment_id.txt')) return;
            const commentId = parseInt(
-              fs.readFileSync(commentIdFile, 'utf8').trim(),
+              fs.readFileSync('comment_id.txt', 'utf8').trim(),
              10
            );
            if (!commentId) return;
@@ -162,7 +147,6 @@ jobs:
          name: ${{ inputs.result_artifact_name }}
          run-id: ${{ github.event.workflow_run.id }}
          github-token: ${{ secrets.GITHUB_TOKEN }}
-          path: _artifact
        continue-on-error: true

      - name: React with failure
@@ -171,11 +155,9 @@ jobs:
        with:
          script: |
            const fs = require('fs');
-            const path = require('path');
-            const commentIdFile = path.join('_artifact', 'comment_id.txt');
-            if (!fs.existsSync(commentIdFile)) return;
+            if (!fs.existsSync('comment_id.txt')) return;
            const commentId = parseInt(
-              fs.readFileSync(commentIdFile, 'utf8').trim(),
+              fs.readFileSync('comment_id.txt', 'utf8').trim(),
              10
            );
            if (!commentId) return;
@@ -25,7 +25,6 @@ jobs:
        name: clang-tidy-result
        run-id: ${{ github.event.workflow_run.id }}
        github-token: ${{ secrets.GITHUB_TOKEN }}
-        path: _artifact
      continue-on-error: true

    - name: Post or update PR comment
@@ -34,19 +33,12 @@ jobs:
      with:
        script: |
          const fs = require('fs');
-          if (!fs.existsSync('_artifact/clang-tidy-comment.md') ||
-              !fs.existsSync('_artifact/pr_number.txt')) {
+          if (!fs.existsSync('clang-tidy-comment.md') || !fs.existsSync('pr_number.txt')) {
            core.info('No clang-tidy results found; skipping.');
            return;
          }
-          const body = fs.readFileSync(
-            '_artifact/clang-tidy-comment.md',
-            'utf8'
-          );
-          const prNumber = parseInt(
-            fs.readFileSync('_artifact/pr_number.txt', 'utf8').trim(),
-            10
-          );
+          const body = fs.readFileSync('clang-tidy-comment.md', 'utf8');
+          const prNumber = parseInt(fs.readFileSync('pr_number.txt', 'utf8').trim());
          const post = require('./.github/scripts/post-pr-comment.js');

          await post({
@@ -22,3 +22,4 @@ jobs:
      provider: claude
      result_artifact_name: claude-review-result
      comment_file: claude-review-comment.md
+    secrets: inherit
@@ -34,7 +34,7 @@ on:
          - claude-sonnet-4-6
        default: claude-opus-4-6
      thinking_budget:
-        description: Override MAX_THINKING_TOKENS (blank = auto-classify, capped at 24000)
+        description: Override MAX_THINKING_TOKENS (blank = auto-classify)
        required: false
        type: string
        default: ""
@@ -22,3 +22,4 @@ jobs:
      provider: codex
      result_artifact_name: codex-review-result
      comment_file: codex-review-comment.md
+    secrets: inherit
@@ -7,9 +7,14 @@
 name: Codex Code Review

 on:
-  # Automatic PR reviews are temporarily disabled while Codex authentication is
-  # repaired. Manual review requests remain available through issue comments
-  # and workflow_dispatch.
+  workflow_run:
+    workflows: ["facebook/rocksdb/pr-jobs"]
+    types: [completed]
+
+  # The early pull_request_target path is limited to same-repo PRs by the job
+  # condition below. Fork PRs skip this path and rely on workflow_run instead.
+  pull_request_target:
+    types: [opened, reopened, synchronize]

  issue_comment:
    types: [created]
@@ -113,10 +113,11 @@ jobs:
    - run: "USE_FOLLY=1 LIB_MODE=static DEBUG_LEVEL=0 V=1 make -j20 release"
    - run: "(mkdir build && cd build && cmake -DUSE_FOLLY=1 -DWITH_GFLAGS=1 -DROCKSDB_BUILD_SHARED=0 -DCMAKE_BUILD_TYPE=Release .. && make VERBOSE=1 -j20 && ctest -j20)"
    - uses: "./.github/actions/post-steps"
-  build-windows-msvc-avx2:
+  build-windows-vs2022-avx2:
    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on: windows-8-core
+    runs-on: windows-2022
    env:
+      CMAKE_GENERATOR: Visual Studio 17 2022
      CMAKE_PORTABLE: AVX2
    steps:
    - uses: actions/checkout@v4.1.0
@@ -314,23 +314,6 @@ jobs:
    - run: CC=clang-21 CXX=clang++-21 USE_CLANG=1 make -j32 all microbench
    - run: make clean
    - run: CC=clang-21 CXX=clang++-21 USE_CLANG=1 DEBUG_LEVEL=0 make -j32 release
-    - name: Install clang-format-21 for C API gen checks
-      run: apt-get update && apt-get install -y clang-format-21
-    - name: Check C API codegen (link-complete, backward-compatible, up to date)
-      # Run the make target in STRICT mode so this core CI job HARD-FAILS rather
-      # than silently skipping if a prerequisite (clang++, clang-format, or the
-      # compat baseline ref) is ever missing. See `make check-c-api-gen`.
-      run: |
-        # The container checkout is owned by a different user, so git refuses to
-        # operate on it ("dubious ownership") -- mark it safe for the `git fetch`
-        # and the `git show` the compat checker runs.
-        git config --global --add safe.directory "$GITHUB_WORKSPACE"
-        git config --global --add safe.directory '*'
-        git fetch --no-tags --depth=1 origin main
-        CXX=clang++-21 make check-c-api-gen \
-          CHECK_C_API_GEN_STRICT=1 \
-          API_COMPAT_REF=FETCH_HEAD \
-          CLANG_FORMAT_BINARY=clang-format-21
    - uses: "./.github/actions/teardown-ccache"
      if: always()
    - uses: "./.github/actions/post-steps"
@@ -390,17 +373,14 @@ jobs:
          crash_duration: 240
    container:
      image: ghcr.io/facebook/rocksdb_ubuntu:22.1
-      options: --shm-size=16gb --ulimit nofile=1048576:1048576
+      options: --shm-size=16gb
    steps:
    - uses: actions/checkout@v4.1.0
    - uses: "./.github/actions/pre-steps"
    - uses: "./.github/actions/setup-ccache"
      with:
        cache-key-prefix: mini-crashtest
-    - run: |
-        ulimit -S -n $(ulimit -Hn) # Raise open files soft limit to hard limit
-        echo "Updated ulimit -Hn: $(ulimit -Hn) -Sn: $(ulimit -Sn)"
-        make V=1 -j8 CRASH_TEST_EXT_ARGS='--duration=${{ matrix.crash_duration }} --max_key=2500000' ${{ matrix.crash_test_target }}
+    - run: ulimit -S -n `ulimit -H -n` && make V=1 -j8 CRASH_TEST_EXT_ARGS='--duration=${{ matrix.crash_duration }} --max_key=2500000' ${{ matrix.crash_test_target }}
    - uses: "./.github/actions/teardown-ccache"
      if: always()
    - uses: "./.github/actions/post-steps"
@@ -542,8 +522,8 @@ jobs:
    - uses: "./.github/actions/post-steps"
  # ======================== Windows with Tests ======================= #
  # NOTE: some windows jobs are in "nightly" to save resources
-  build-windows-msvc:
-    if: needs.config.outputs.only_job == 'build-windows-msvc' || (needs.config.outputs.only_job == '' && github.repository_owner == 'facebook')
+  build-windows-vs2022:
+    if: needs.config.outputs.only_job == 'build-windows-vs2022' || (needs.config.outputs.only_job == '' && github.repository_owner == 'facebook')
    needs: config
    runs-on: windows-8-core
    strategy:
@@ -554,12 +534,13 @@ jobs:
          suite_run: db_test
          run_java: "false"
        - test_shard: other
-          suite_run: arena_test,db_basic_test,db_etc2_test,db_merge_operand_test,bloom_test,c_test,coding_test,crc32c_test,dynamic_bloom_test,env_basic_test,env_test,hash_test,random_test
+          suite_run: arena_test,db_basic_test,db_test2,db_merge_operand_test,bloom_test,c_test,coding_test,crc32c_test,dynamic_bloom_test,env_basic_test,env_test,hash_test,random_test
          run_java: "false"
        - test_shard: java
          suite_run: ""
          run_java: "true"
    env:
+      CMAKE_GENERATOR: Visual Studio 17 2022
      CMAKE_PORTABLE: 1
    steps:
    - uses: actions/checkout@v4.1.0
@@ -619,6 +600,7 @@ jobs:
    needs: config
    runs-on: macos-15-xlarge
    env:
+      JAVA_HOME: "/Library/Java/JavaVirtualMachines/liberica-jdk-8.jdk/Contents/Home"
      ROCKSDB_DISABLE_JEMALLOC: 1
    steps:
    - uses: actions/checkout@v4.1.0
@@ -630,7 +612,7 @@ jobs:
        cache-key-prefix: macos-java
    - uses: "./.github/actions/increase-max-open-files-on-macos"
    - uses: "./.github/actions/install-gflags-on-macos"
-    - uses: "./.github/actions/setup-jdk-on-macos"
+    - uses: "./.github/actions/install-jdk8-on-macos"
    - uses: "./.github/actions/pre-steps-macos"
    - name: Set Java Environment
      run: |-
@@ -646,6 +628,8 @@ jobs:
    if: needs.config.outputs.only_job == 'build-macos-java-static' || (needs.config.outputs.only_job == '' && github.repository_owner == 'facebook')
    needs: config
    runs-on: macos-15-xlarge
+    env:
+      JAVA_HOME: "/Library/Java/JavaVirtualMachines/liberica-jdk-8.jdk/Contents/Home"
    steps:
    - uses: actions/checkout@v4.1.0
    - uses: maxim-lobanov/setup-xcode@v1.6.0
@@ -656,7 +640,7 @@ jobs:
        cache-key-prefix: macos-java-static
    - uses: "./.github/actions/increase-max-open-files-on-macos"
    - uses: "./.github/actions/install-gflags-on-macos"
-    - uses: "./.github/actions/setup-jdk-on-macos"
+    - uses: "./.github/actions/install-jdk8-on-macos"
    - uses: "./.github/actions/pre-steps-macos"
    - name: Set Java Environment
      run: |-
@@ -672,6 +656,8 @@ jobs:
    if: needs.config.outputs.only_job == 'build-macos-java-static-universal' || (needs.config.outputs.only_job == '' && github.repository_owner == 'facebook')
    needs: config
    runs-on: macos-15-xlarge
+    env:
+      JAVA_HOME: "/Library/Java/JavaVirtualMachines/liberica-jdk-8.jdk/Contents/Home"
    steps:
    - uses: actions/checkout@v4.1.0
    - uses: maxim-lobanov/setup-xcode@v1.6.0
@@ -682,7 +668,7 @@ jobs:
        cache-key-prefix: macos-java-static-universal
    - uses: "./.github/actions/increase-max-open-files-on-macos"
    - uses: "./.github/actions/install-gflags-on-macos"
-    - uses: "./.github/actions/setup-jdk-on-macos"
+    - uses: "./.github/actions/install-jdk8-on-macos"
    - uses: "./.github/actions/pre-steps-macos"
    - name: Set Java Environment
      run: |-
@@ -1,7 +1,5 @@
 make_config.mk
 rocksdb.pc
-.build_signature
-build_tools/__pycache__/

 *.a
 *.arc
@@ -54,7 +52,7 @@ GRTAGS
 GTAGS
 rocksdb_dump
 rocksdb_undump
-db_etc2_test
+db_test2
 trace_analyzer
 block_cache_trace_analyzer
 io_tracer_parser
@@ -90,8 +88,6 @@ fbcode/
 fbcode
 buckifier/*.pyc
 buckifier/__pycache__
-tools/__pycache__/
-tools/c_api_gen/__pycache__/
 .arcconfig

 compile_commands.json
@@ -35,13 +35,15 @@ cpp_library_wrapper(name="rocksdb_lib", srcs=[
        "db/blob/blob_file_partition_manager.cc",
        "db/blob/blob_file_reader.cc",
        "db/blob/blob_garbage_meter.cc",
-        "db/blob/blob_gen2_format.cc",
        "db/blob/blob_log_format.cc",
        "db/blob/blob_log_sequential_reader.cc",
        "db/blob/blob_log_writer.cc",
        "db/blob/blob_source.cc",
        "db/blob/blob_write_batch_transformer.cc",
        "db/blob/prefetch_buffer_collection.cc",
+        "db/blog/blog_format.cc",
+        "db/blog/blog_reader.cc",
+        "db/blog/blog_writer.cc",
        "db/builder.cc",
        "db/c.cc",
        "db/coalescing_iterator.cc",
@@ -4593,6 +4595,18 @@ cpp_unittest_wrapper(name="block_test",
            extra_compiler_flags=[])


+cpp_unittest_wrapper(name="blog_format_test",
+            srcs=["db/blog/blog_format_test.cc"],
+            deps=[":rocksdb_test_lib"],
+            extra_compiler_flags=[])
+
+
+cpp_unittest_wrapper(name="blog_writer_test",
+            srcs=["db/blog/blog_writer_test.cc"],
+            deps=[":rocksdb_test_lib"],
+            extra_compiler_flags=[])
+
+
 cpp_unittest_wrapper(name="bloom_test",
            srcs=["util/bloom_test.cc"],
            deps=[":rocksdb_test_lib"],
@@ -4869,12 +4883,6 @@ cpp_unittest_wrapper(name="db_encryption_test",
            extra_compiler_flags=[])


-cpp_unittest_wrapper(name="db_etc2_test",
-            srcs=["db/db_etc2_test.cc"],
-            deps=[":rocksdb_test_lib"],
-            extra_compiler_flags=[])
-
-
 cpp_unittest_wrapper(name="db_etc3_test",
            srcs=["db/db_etc3_test.cc"],
            deps=[":rocksdb_test_lib"],
@@ -5031,6 +5039,12 @@ cpp_unittest_wrapper(name="db_test",
            extra_compiler_flags=[])


+cpp_unittest_wrapper(name="db_test2",
+            srcs=["db/db_test2.cc"],
+            deps=[":rocksdb_test_lib"],
+            extra_compiler_flags=[])
+
+
 cpp_unittest_wrapper(name="db_universal_compaction_test",
            srcs=["db/db_universal_compaction_test.cc"],
            deps=[":rocksdb_test_lib"],
@@ -5796,5 +5810,3 @@ cpp_unittest_wrapper(name="write_unprepared_transaction_test",


 export_file(name = "tools/db_crashtest.py")
-
-export_file(name = "tools/fault_injection_log_parser.py")
@@ -38,7 +38,7 @@ This document provides guidance for generating and reviewing code in the RocksDB

 **SIMD and Vectorization:** Leverage SIMD instructions (SSE, AVX) for data-parallel operations when appropriate. Structure data to enable auto-vectorization by the compiler. Consider explicit SIMD intrinsics for critical hot paths like checksum computation, encoding/decoding, and bulk data processing.

-**Branch Prediction:** Minimize unpredictable branches in hot paths. Use `LIKELY`/`UNLIKELY` macros to hint branch prediction, e.g. for error cases and other rare or otherwise costly cases, but NOT for predicting popular configurations. Consider branchless alternatives for simple conditionals. Order switch cases and if-else chains by frequency.
+**Branch Prediction:** Minimize unpredictable branches in hot paths. Use `LIKELY`/`UNLIKELY` macros to hint branch prediction. Consider branchless alternatives for simple conditionals. Order switch cases and if-else chains by frequency.

 **Memory and Resource Management:** Be mindful of memory allocations, especially in hot paths. Use RAII patterns, smart pointers, and RocksDB's memory management utilities appropriately.

@@ -149,26 +149,6 @@ Cache management is critical for RocksDB's performance.

 When reviewing RocksDB code (or preparing code for review), use this checklist:

-### Contract Boundaries
- [ ] Is each behavior owned by the right layer? High-level policy (for example,
-  "compaction wants this I/O mode") should live at the caller/policy layer, while
-  lower layers should expose generic mechanisms (for example, "open a fresh
-  reader", "skip shared cache insertion", or "use these FileOptions").
- [ ] Do comments and names describe local contracts rather than leaking a
-  specific caller's rationale into reusable APIs? Generic code should not need to
-  know about one current use case unless the API itself is intentionally
-  use-case-specific.
- [ ] Does each flag or parameter control one coherent behavior? If one boolean
-  starts implying ownership, cache policy, I/O mode, prefetching, and caller
-  identity, split it into explicit flags or an options struct.
- [ ] Could a future caller use this lower-level API without accidentally
-  inheriting assumptions from compaction, backup, user reads, or a particular
-  table format? If not, tighten the contract with assertions, clearer names, or
-  a narrower API.
- [ ] Are implementation details not being used as policy signals? Prefer an
-  explicit contract over inferring behavior from incidental fields such as file
-  options, cache handles, or current table-reader state.
-
 ### Correctness
 - [ ] Does the change preserve database semantics (e.g., snapshot isolation, key ordering)?
 - [ ] Are all error cases handled appropriately?
@@ -224,100 +204,18 @@ The following patterns emerged as frequent sources of review feedback:

 10. **Platform Compatibility:** Ensure changes work correctly on all supported platforms (Linux, Windows, macOS) and with all supported compilers (GCC, Clang, MSVC).

-11. **Contract Boundary Leaks:** When a change plumbs a new option or use-case
-specific behavior through multiple subsystems, review the call chain for
-contract leaks. Caller-specific rationale belongs at the call site or public API
-documentation; reusable layers should expose precise, layer-local capabilities.
-Watch especially for comments mentioning one caller in generic code, booleans
-that silently bundle several behaviors, and downstream code inferring policy
-from an implementation detail instead of an explicit option.
-
 ---

 ## Important tips

 ### Build system
-* There are 3 build system. Make for git clones, BUCK (meta internal) for hg
-  clones, and CMake for some special cases.
+* There are 3 build system. Make, CMake, BUCK(meta internal).
 * When a new .cc file is added, update Makefile, CMakeLists.txt, src.mk, BUCK.
 * Don't manually edit BUCK file, after updating src.mk, run
    /usr/local/bin/python3 buckifier/buckify_rocksdb.py to update it
+* Use make to build and run the test. CMake and BUCK are not used locally.
+* Use `make dbg` command to build all of the unit test in debug mode.
 * For -j in make command, use the number of CPU cores to decide it.
-* When searching for references to something (a symbol, library, etc.), do not
-  restrict or truncate your search based on presumed relevance or scope. It is
-  important and time-saving to keep the repo reasonably consistent across
-  different build systems, programming languages, and even between
-  documentation and implementation.
-
-### Avoiding mixed build modes with Make (use `AUTO_CLEAN=1`)
-
-Object files are written to the same paths regardless of build flags, so
-reusing objects from a prior build with different flags causes confusing
-linker errors, etc. This problem is essentially avoidable by ALWAYS using
-`AUTO_CLEAN=1 make -j<n> <something>` for manual make invocations. This
-will automatically clean object files if the build parameters/flavor have
-changed. The `build_tools/rockstest.sh` / `rocksptest.sh` helpers described
-below set `AUTO_CLEAN=1` for you.
-
-### Source checks
-* Run `make check-sources` before committing. This catches non-ASCII
-    characters in source files and other source-level issues that CI will
-    reject. In particular, **do not use Unicode characters** (em dashes,
-    smart quotes, etc.) in comments or strings -- use ASCII equivalents
-    (`--` instead of em dash, `'` instead of smart quote, etc.).
-
-### License headers
-* Every new source file needs a license header. For a file that does **not**
-    carry an outside/third-party copyright, use the standard Meta dual-licensed
-    header (the dual-license designation is required -- a bare
-    "All Rights Reserved" copyright is not an acceptable open-source header):
-    ```
-    //  Copyright (c) Meta Platforms, Inc. and affiliates.
-    //  This source code is licensed under both the GPLv2 (found in the
-    //  COPYING file in the root directory) and Apache 2.0 License
-    //  (found in the LICENSE.Apache file in the root directory).
-    ```
-    Use a `#` comment prefix instead of `//` for shell, Python, and Makefile
-    fragments.
-* Files derived from an external source (e.g. LevelDB) keep their original
-    upstream copyright line in addition to the header above.
-
-### RTTI and dynamic_cast
-* Production code and `db_stress` must build in **release mode
-    (`-fno-rtti`)**. Do not use `dynamic_cast` anywhere except unit tests.
-    Use `static_cast_with_check` from `util/cast_util.h` (validates with
-    `dynamic_cast` in debug builds, plain `static_cast` in release).
-* Unit tests (`*_test.cc`) are built in debug mode with RTTI enabled.
-
-### Cross-platform / portability
-Local `make` only exercises Linux with GCC/Clang, but CI
-(`.github/workflows/pr-jobs.yml` and `nightly.yml`) gates on a much wider
-matrix, so portability breaks are invisible locally until CI fails. Code must
-build (and where noted, run tests) across:
-
-| Axis | Must support |
-|------|--------------|
-| OS | Linux (x86_64 + ARM), macOS, Windows |
-| Architecture | Little-endian and big-endian targets, including Linux on s390x |
-| Compiler | GCC, Clang (libstdc++ **and** libc++), AppleClang, **MSVC (VS2022)**, MinGW (Linux cross-compile, build-only, no gflags) |
-| Build system | Make, CMake, and BUCK (internal) -- keep all in sync (see "Build system" above) |
-| Config | release (`-fno-rtti`), `ASSERT_STATUS_CHECKED`, ASAN/UBSAN/TSAN, folly, unity build, JNI/Java |
-
-Treat these as constraints to satisfy and infer the specifics from them before
-adding any system header, libc call, or compiler-specific construct. The most
-common trap: anything that compiles under GCC/Clang on Linux but not under
-**MSVC/MinGW** -- e.g. unguarded POSIX-only headers/functions (`<unistd.h>`,
-`<sys/*.h>`, `getpid`, `_exit`, ...) or GCC/Clang extensions
-(`__attribute__`, `__builtin_*`, VLAs, `alloca`). Prefer the `port::`/`Env`
-abstractions; otherwise guard with `#ifdef OS_WIN` (POSIX `<unistd.h>` ->
-Windows `<process.h>`). Because libc++ is also tested, include what you use
-rather than relying on libstdc++ transitive includes.
-
-Do not use `static_assert` to reject a supported architecture for an optional
-feature. Check an existing `port::` capability such as `port::kLittleEndian`
-and disable only the unsupported feature so the rest of RocksDB still builds.
-Use a portable representation when the feature itself must work across
-architectures.

 ### Unit Test
 * After all of the unit tests are added, review them and try to extract common
@@ -326,26 +224,14 @@ architectures.
 * Don't use sleep to wait for certain events to happen. This will cause test to
    be flaky. Instead, use sync point to synchronize thread progress.
 * Cap unit test execution with 60 seconds timeout.
-* To build and run unit tests locally, prefer these helper scripts:
-    * `build_tools/rocksptest.sh <test_binary> [more_binaries...] [args...]`
-        builds the binary(ies) with parallel make and `AUTO_CLEAN=1` and runs
-        them under gtest-parallel, sharding the test cases across CPUs. Prefer
-        this whenever running more than a couple of test cases, e.g.
-        `build_tools/rocksptest.sh table_test` or
-        `build_tools/rocksptest.sh db_test env_test --gtest_filter=*Foo*`.
-    * `build_tools/rockstest.sh <test_binary> [args...]` builds with parallel
-        make and `AUTO_CLEAN=1` and runs the binary directly (serially).
-        Use it only for a very small number of test cases, e.g.
-        `build_tools/rockstest.sh db_test --gtest_filter=*MixedSlowdown*`.
-* After writing a test, stress-test for flakiness (AUTO_CLEAN handles the
-    rebuild needed by the `COERCE_CONTEXT_SWITCH=1` flag change):
+* When there are multiple unit tests need to be executed, try to use
+    gtest_parallel.py if available. E.g.
+    python3 ${GTEST_PARALLEL}/gtest_parallel.py ./table_test
+* After writing a test, stress-test for flakiness:
    ```bash
-    COERCE_CONTEXT_SWITCH=1 build_tools/rockstest.sh {test_binary} -r100 \
-        --gtest_filter="*YourTestName*"
+    COERCE_CONTEXT_SWITCH=1 make {test_binary}
+    ./{test_binary} --gtest_filter="*YourTestName*" --gtest_repeat=5
    ```
-* For CI-style flaky tests that do not reproduce with `gtest_parallel.py`,
-    `--gtest_repeat`, or normal coerce-mode runs, inspect
-    `tools/gtest_parallel_repro.py --help`.

 ### Unit test dedup guidelines
 * Extract helper functions for repeated patterns such as object
@@ -398,13 +284,12 @@ architectures.
 * Blog post authors must be defined in `docs/_data/authors.yml` to be displayed

 ### Final verification of the change
-* Execute `AUTO_CLEAN=1 make check` to build all of the changes and execute all
-    of the tests. `AUTO_CLEAN=1` ensures a clean rebuild if your previous build
-    used different parameters. Note that executing all of the tests could take
-    multiple minutes.
-* Run `AUTO_CLEAN=1 ASSERT_STATUS_CHECKED=1 make check` to verify all Status
-    objects are properly checked. This catches missing error handling that can
-    lead to silent data corruption.
+* Execute make clean to clean all of the changes.
+* Execute make check to build all of the changes and execute all of the tests.
+    Note that executing all of the tests could take multiple minutes.
+* Run `ASSERT_STATUS_CHECKED=1 make check` to verify all Status objects are
+    properly checked. This catches missing error handling that can lead to
+    silent data corruption.

 ### Monitoring make check progress
 * Use `make check-progress` to get machine-parseable JSON progress while
@@ -412,7 +297,7 @@ architectures.
    builds without timeout issues.
 * Run `make check` in background, then poll progress:
    ```bash
-    AUTO_CLEAN=1 make check &
+    make check &
    # Poll periodically:
    make check-progress
    ```
@@ -437,10 +322,9 @@ architectures.

 ### Executing benchmark using db_bench
 * Since the goal is to measure performance, we need to build a release binary
-    using `AUTO_CLEAN=1 DEBUG_LEVEL=0 make db_bench`. If there is an engine
-    crash due to a bug, switch back to a debug build with
-    `AUTO_CLEAN=1 make dbg`; `AUTO_CLEAN=1` handles the release<->debug rebuild
-    automatically.
+    using `make clean && DEBUG_LEVEL=0 make db_bench`. If there is an engine
+    crash due to bug, we need to switch back to debug build. Make sure to run
+    `make clean` before running `make dbg`.

 ### Formatting code
 * After making change, use `make format-auto` to auto-apply formatting without
@@ -420,6 +420,13 @@ if(WITH_NUMA)
  list(APPEND THIRDPARTY_LIBS NUMA::NUMA)
 endif()

+option(WITH_TBB "build with Threading Building Blocks (TBB)" OFF)
+if(WITH_TBB)
+  find_package(TBB REQUIRED)
+  add_definitions(-DTBB)
+  list(APPEND THIRDPARTY_LIBS TBB::TBB)
+endif()
+
 # Stall notifications eat some performance from inserts
 option(DISABLE_STALL_NOTIF "Build with stall notifications" OFF)
 if(DISABLE_STALL_NOTIF)
@@ -647,8 +654,6 @@ if(USE_FOLLY)
    FMT_INST_PATH)
    exec_program(ls ARGS -d ${FOLLY_INST_PATH}/../gflags* OUTPUT_VARIABLE
    GFLAGS_INST_PATH)
-    exec_program(ls ARGS -d ${FOLLY_INST_PATH}/../glog* OUTPUT_VARIABLE
-    GLOG_INST_PATH)
    set(Boost_DIR ${BOOST_INST_PATH}/lib/cmake/Boost-1.83.0)
    if(EXISTS ${FMT_INST_PATH}/lib64)
      set(fmt_DIR ${FMT_INST_PATH}/lib64/cmake/fmt)
@@ -656,61 +661,16 @@ if(USE_FOLLY)
      set(fmt_DIR ${FMT_INST_PATH}/lib/cmake/fmt)
    endif()
    set(gflags_DIR ${GFLAGS_INST_PATH}/lib/cmake/gflags)
-    if(EXISTS ${GLOG_INST_PATH}/lib64/cmake/glog)
-      set(GLOG_CMAKE_DIR ${GLOG_INST_PATH}/lib64/cmake/glog)
-    elseif(EXISTS ${GLOG_INST_PATH}/lib/cmake/glog)
-      set(GLOG_CMAKE_DIR ${GLOG_INST_PATH}/lib/cmake/glog)
-    endif()
-    if(NOT GLOG_CMAKE_DIR)
-      find_library(GETDEPS_GLOG_LIBRARY NAMES glogd glog
-        PATHS ${GLOG_INST_PATH}/lib64 ${GLOG_INST_PATH}/lib
-        NO_DEFAULT_PATH)
-      if(NOT GETDEPS_GLOG_LIBRARY OR
-         NOT EXISTS ${GLOG_INST_PATH}/include/glog/logging.h)
-        message(FATAL_ERROR "Could not find getdeps glog under "
-          "${GLOG_INST_PATH}")
-      endif()
-      set(GLOG_CMAKE_DIR ${CMAKE_CURRENT_BINARY_DIR}/getdeps-glog-cmake)
-      file(MAKE_DIRECTORY ${GLOG_CMAKE_DIR})
-      file(WRITE ${GLOG_CMAKE_DIR}/glog-config.cmake
-        "if(NOT TARGET glog::glog)\n"
-        "  add_library(glog::glog UNKNOWN IMPORTED)\n"
-        "  set_target_properties(glog::glog PROPERTIES\n"
-        "    IMPORTED_LOCATION \"${GETDEPS_GLOG_LIBRARY}\"\n"
-        "    INTERFACE_INCLUDE_DIRECTORIES \"${GLOG_INST_PATH}/include\")\n"
-        "endif()\n"
-        "set(glog_FOUND TRUE)\n"
-        "set(Glog_FOUND TRUE)\n"
-        "set(GLOG_FOUND TRUE)\n"
-        "set(GLOG_LIBRARY \"${GETDEPS_GLOG_LIBRARY}\")\n"
-        "set(GLOG_LIBRARIES \"${GETDEPS_GLOG_LIBRARY}\")\n"
-        "set(GLOG_INCLUDE_DIR \"${GLOG_INST_PATH}/include\")\n")
-    endif()
-    set(glog_DIR ${GLOG_CMAKE_DIR})
-    set(Glog_DIR ${GLOG_CMAKE_DIR})
-    # Unlike gflags, glog may also be installed system-wide. Pre-resolve the
-    # getdeps copy so folly-config.cmake cannot fall back to another version.
-    find_package(glog CONFIG REQUIRED PATHS ${GLOG_CMAKE_DIR}
-                 NO_DEFAULT_PATH)

    exec_program(sed ARGS -i 's/gflags_shared//g'
    ${FOLLY_INST_PATH}/lib/cmake/folly/folly-targets.cmake)

    include(${FOLLY_INST_PATH}/lib/cmake/folly/folly-config.cmake)

-    # Fix gflags library name for debug builds. The getdeps gflags shared
-    # library is versioned (e.g. libgflags_debug.so.2.3), so resolve the
-    # actual file by glob rather than hard-coding a version.
+    # Fix gflags library name for debug builds
    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-      file(GLOB GFLAGS_DEBUG_SHARED_LIBS
-        "${GFLAGS_INST_PATH}/lib/libgflags_debug.so.*")
-      if(NOT GFLAGS_DEBUG_SHARED_LIBS)
-        message(FATAL_ERROR
-          "Could not find getdeps libgflags_debug.so under ${GFLAGS_INST_PATH}/lib")
-      endif()
-      list(GET GFLAGS_DEBUG_SHARED_LIBS 0 GFLAGS_DEBUG_SHARED_LIB)
      set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-rpath=${GFLAGS_INST_PATH}/lib")
-      set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${GFLAGS_DEBUG_SHARED_LIB}")
+      set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${GFLAGS_INST_PATH}/lib/libgflags_debug.so.2.2")
    endif()
  endif()

@@ -777,13 +737,15 @@ set(SOURCES
        db/blob/blob_file_meta.cc
        db/blob/blob_file_reader.cc
        db/blob/blob_garbage_meter.cc
-        db/blob/blob_gen2_format.cc
        db/blob/blob_log_format.cc
        db/blob/blob_log_sequential_reader.cc
        db/blob/blob_log_writer.cc
        db/blob/blob_source.cc
        db/blob/blob_write_batch_transformer.cc
        db/blob/prefetch_buffer_collection.cc
+        db/blog/blog_format.cc
+        db/blog/blog_reader.cc
+        db/blog/blog_writer.cc
        db/builder.cc
        db/c.cc
        db/coalescing_iterator.cc
@@ -1472,6 +1434,8 @@ if(WITH_TESTS)
        db/blob/db_blob_compaction_test.cc
        db/blob/db_blob_corruption_test.cc
        db/blob/db_blob_index_test.cc
+        db/blog/blog_format_test.cc
+        db/blog/blog_writer_test.cc
        db/column_family_test.cc
        db/compact_files_test.cc
        db/compaction/clipping_iterator_test.cc
@@ -1494,7 +1458,6 @@ if(WITH_TESTS)
        db/db_clip_test.cc
        db/db_dynamic_level_test.cc
        db/db_encryption_test.cc
-        db/db_etc2_test.cc
        db/db_etc3_test.cc
        db/db_flush_test.cc
        db/db_inplace_update_test.cc
@@ -1518,6 +1481,7 @@ if(WITH_TESTS)
        db/db_table_properties_test.cc
        db/db_tailing_iter_test.cc
        db/db_test.cc
+        db/db_test2.cc
        db/db_logical_block_size_cache_test.cc
        db/db_universal_compaction_test.cc
        db/db_wal_test.cc
@@ -1,101 +1,6 @@
 # Rocksdb Change Log
 > NOTE: Entries for next release do not go here. Follow instructions in `unreleased_history/README.txt`

-## 11.7.0 (07/16/2026)
-### Public API Changes
-* Added `RangeLockManagerHandle::SetIsKilledCallback()`, a `std::function<bool()>` predicate polled during range-lock waits. When it returns true, a blocked `GetRangeLock()` wait returns promptly with `Status::Aborted()` instead of waiting for the lock timeout. Range-lock users that install no callback keep the original wait-until-grant-or-timeout behavior.
-* Added `MultiScanArgs::reverse` to support reverse MultiScan reads over bounded scan ranges.
-
-### Behavior Changes
-* When using `LockWAL()`, live-file capture APIs such as checkpoint and backup now flush WAL-disabled unpersisted data; they can block until `UnlockWAL()` or return `Aborted` when called from the same thread that holds `LockWAL()` to avoid deadlock. `UnlockWAL()` must now also be called from the same thread that called `LockWAL()`.
-
-### Performance Improvements
-* Fixed slow DB open with `best_efforts_recovery`, and slow catch-up of secondary and follower (read-only) instances, in which time and memory grew quadratically with the number of files in the DB (so the slowdown was worst for large DBs with long history).
-
-## 11.6.0 (07/02/2026)
-### New Features
-* Added EXPERIMENTAL embedded blob SST support through `SstFileWriter::OpenWithEmbeddedBlobs()`, storing eligible large values as same-file blob records in block-based SST files and resolving them transparently for reads. This niche feature currently supports uncompressed embedded blobs only; compression options are placeholders and compression support is deferred to follow-up work.
-
-### Public API Changes
-* Expanded the C API (`include/rocksdb/c.h`) with a large set of new `rocksdb_*` functions, mostly option getters/setters plus table-properties, job/event-listener, and metadata accessors, a WAL filter, a ReadOptions table filter, and a backup exclude-files callback. Many are now produced by a new semi-automated generator (`tools/c_api_gen/`) from the C++ headers; `include/rocksdb/c.h` remains a single self-contained header and the signatures of pre-existing functions are unchanged.
-
-### Bug Fixes
-* Reverted PR14831 that made range_lock_manager aware of reverse-order CF
-* Fixed a bug in `RandomAccessFileReader::ReadAsync` where an already-aligned direct-IO read request with a null `scratch` and a caller-provided `aligned_buf` would take the "already aligned" fast path and submit the null buffer to the underlying async read (e.g. a null iovec base to io_uring, failing with EFAULT). This could surface as spurious iterator failures during async prefetch (MultiScan with async IO) on direct-IO databases. The async path now allocates a backing buffer in this case, matching the synchronous `Read` path.
-* Fixed a bug where closing a read-only DB instance could delete live SST files created by a concurrent read-write DB sharing the same directory.
-
-## 11.5.0 (06/16/2026)
-### New Features
-* External table readers that open files through `ExternalTableOptions::fs` now update RocksDB SST/file-read statistics and file IO listener callbacks, making external file IO activity visible in existing read metrics.
-* Added `DB::PrepareFileIngestion()`, a two-phase form of `IngestExternalFile`/`IngestExternalFiles`. `PrepareFileIngestion()` performs all of the work that does not require the DB mutex (validating the arguments, reading each external file's metadata, and linking/copying the files into the DB) and returns an opaque `FileIngestionHandle`. `DB::CommitFileIngestionHandle()` (or `DB::CommitFileIngestionHandles()` for several handles at once) then makes the prepared files visible; multiple handles are committed atomically in a single MANIFEST write, or none are. `FileIngestionHandle::Abort()` (or simply destroying the handle) cancels a prepared ingestion and rolls it back. This gives flexibility to the application to Prepare a file separately from when its committed, and may shorten an applications critical path on `IngestExternalFile`.
-* Added two stats histograms reporting the per-call latency (in microseconds) of each successful `IngestExternalFile`/`IngestExternalFiles` call, split by phase: `rocksdb.ingest.external.file.prepare.micros` (argument validation and reading/validating/linking the external files, which does not block live writes) and `rocksdb.ingest.external.file.run.micros` (the ingestion performed under the DB mutex while live writes are blocked). Failed ingestions are not recorded.
-* Added `DBOptions::use_direct_io_for_compaction_reads` (default false). When enabled, compaction-input SST reads use `O_DIRECT` while user reads remain buffered, avoiding page-cache eviction of hot user-read data by sequential compaction scans. Pair with `use_direct_io_for_flush_and_compaction = true` on write-heavy workloads for direct I/O on both compaction inputs and outputs. Rejected at Open when combined with `allow_mmap_reads = true`. No-op when `use_direct_reads = true` is already set (since all reads are already direct).
-
-### Public API Changes
-* `DB::GetPreparedFileInfoForExternalSstIngestion()` can now prepare metadata for a live DB-generated SST file so it can be passed to `IngestExternalFileArg::file_infos`. The input path must exactly match a live table file owned by the source DB, and the returned metadata handle must outlive the ingestion.
-* `ExternalSstFileInfo` gained a `prepared_file_info` member produced by `SstFileWriter::Finish`, and `IngestExternalFileArg` gained a `file_infos` field: a vector of borrowed `const PreparedFileInfo*` pointers, parallel to `external_files`. The owning `ExternalSstFileInfo::prepared_file_info` handle must outlive the ingestion. When set, `IngestExternalFiles()` reuses the supplied per-file metadata instead of re-opening and scanning each file to recompute it, avoiding that extra I/O.
-* Corrected the public C++ option spelling from `memtable_veirfy_per_key_checksum_on_seek` to `memtable_verify_per_key_checksum_on_seek`. RocksDB continues to accept the old misspelled OPTIONS-file key for compatibility, while newly serialized OPTIONS files use the corrected key.
-* Added experimental read-scoped block buffer provider API, configured through `ReadOptions::read_scoped_block_buffer_provider`, for supported block-based table iterator scans and MultiScan reads to use caller-provided read-scoped storage for final data-block contents. When configured, supported provider-backed scan data-block reads bypass the data-block cache. The provider is ignored when mmap reads are enabled. RocksDB may still use ordinary temporary scratch for serialized block bytes, such as when a block may be compressed. Get and MultiGet do not currently provide API guarantees for this provider.
-* Added `FileSystem::SyncFile()` and `Env::SyncFile()` public APIs for syncing or fsyncing a file by name without requiring callers to reopen it as writable.
-
-### Behavior Changes
-* The default `compression` for column families is now `kLZ4Compression` rather than `kSnappyCompression`. This affects only column families that do not explicitly set `compression`, and only newly-written SST files. The change is fully compatible: existing data remains readable with no migration needed, as RocksDB selects the decompressor per block. LZ4 offers slightly better compression ratios and decompression CPU efficiency vs. Snappy and similar compression CPU, tested across various server CPUs. When support is not compiled in, the fallback path for default compression is LZ4 -> Snappy -> NoCompression.
-* Disable parallel compression (ignore `CompressionOptions::parallel_threads`) for fast built-in compressors: Snappy, LZ4 (accelerated, not LZ4HC), and accelerated levels of ZSTD (level < 0). These do not generally benefit from parallel compression. This behavior can be overridden with a custom Compressor from a custom CompressionManager.
-* `PosixFileSystem::OptimizeForCompactionTableRead` now delegates to the base `FileSystem::OptimizeForCompactionTableRead` implementation before applying its Linux-only compaction-readahead clamp (added for #12038). The returned `FileOptions::use_direct_reads` therefore reflects `DBOptions::use_direct_reads`, consistent with the base class and with other `FileSystem` implementations. Previously the override ignored the base implementation and keyed both the returned options and the Linux readahead clamp off the incoming `FileOptions` rather than `DBOptions`. At the in-tree call site the incoming `FileOptions::use_direct_reads` already matches `DBOptions::use_direct_reads`, so this is effectively a no-op for existing configurations; it removes a latent inconsistency where a caller passing `FileOptions` whose `use_direct_reads` disagreed with `DBOptions` would have had the global flag silently ignored for compaction-input reads on Linux. (Note: the `#12038` readahead clamp still keys off the global `use_direct_reads`; it is not skipped for the compaction-only `use_direct_io_for_compaction_reads` path, since that flag enables O_DIRECT after this hook runs.)
-* Brought more unity to `kLZ4Compression` and `kLZ4HCCompression` by giving each access to the other's compression levels. Negative (fast) values previously only available to LZ4 and positive (slow) values previously only available to LZ4HC are now available to both, so configuring a non-default `compression_opts.level` now selects the LZ4 compressor variant. This is a behavior change for previously tolerated but dubious configurations such as positive compression level with `kLZ4Compression`. `kLZ4Compression` and `kLZ4HCCompression` keep their effective default levels, equivalent to -1 and 9 respectively.
-* Removed a discontinuity in `kZSTD` compression levels at `compression_opts.level == 0` by mapping that setting to `level = -1` rather than to `level = 3` as the ZSTD library does internally. This improves the compression auto-tuning landscape.
-
-### Bug Fixes
-* Fixed a bug where the range lock manager would crash with an assertion failure when using a reverse comparator column family.
-
-### Performance Improvements
-* Reduced commit latency when ingesting many external files by allowing `IngestExternalFileOptions::file_opening_threads` to open table readers for committed ingested files using multiple threads.
-* Reduced commit latency for large external file ingestions into the last level by adding `IngestExternalFileOptions::prefetch_lmax_index_and_filter_blocks`, which can skip commit-time index and filter block prefetching for cache-backed table metadata.
-
-## 11.4.0 (06/02/2026)
-### Public API Changes
-* Added `rocksdb_options_set_memtable_batch_lookup_optimization()` and `rocksdb_options_get_memtable_batch_lookup_optimization()` to the C API, exposing the existing `AdvancedColumnFamilyOptions::memtable_batch_lookup_optimization` field. This allows C API users (and downstream language bindings) to enable the skip-list memtable's batch-lookup optimization for `MultiGet`, which caches the search path between consecutive keys and reduces per-key cost from O(log N) to O(log d) where d is the distance between consecutive keys.
-* Added `rocksdb_readoptions_set_optimize_multiget_for_io()` and `rocksdb_readoptions_get_optimize_multiget_for_io()` to the C API, exposing the existing `ReadOptions::optimize_multiget_for_io` field. This allows C API users (and downstream language bindings) to opt out of the multi-level parallel MultiGet path, which only takes effect when the library is built with `USE_COROUTINES`.
-* Added `rocksdb_block_based_table_index_block_search_type_auto` enum constant and the `rocksdb_block_based_options_set_uniform_cv_threshold()` setter to the C API. The constant exposes `BlockSearchType::kAuto`, and the setter exposes `BlockBasedTableOptions::uniform_cv_threshold`. Both are required for `kAuto` index-block search to take effect from the C API: without setting `uniform_cv_threshold >= 0`, the per-block `is_uniform` footer bit is never written, and `kAuto` falls back to binary search at read time.
-* Added `EventListener::OnDBShutdownBegin`, a callback that fires once when a DB begins shutdown, including when RocksDB cleans up a failed `DB::Open()` attempt.
-* Added a new PerfContext counter `blob_cache_read_byte` for blob cache bytes read.
-
-### Behavior Changes
-* Remote compaction now falls back to local compaction when the primary cannot deserialize a successful `CompactionServiceResult` before installing any remote output files.
-* StringToMap (rocksdb/convenience.h) now preserves the outer braces of nested values so each map entry is in self-contained form and can be embedded directly into another `key=value;` string (e.g. SetOptions) without losing inner ';' delimiters. A new symmetric MapToString utility is provided.
-
-### Bug Fixes
-* Fixed a bug where `AbortAllCompactions()` could leave automatic compaction work unscheduled when aborting before the background worker picked it, causing compaction and write stalls until DB restart.
-* Fix a bug where db had a false positive compaction corruption error due to remote compaction service result with `has_accurate_num_input_records=false` not being serialized.
-* Fixed WritePrepared TransactionDB cleanup after retryable commit or rollback write failures so prepared transactions remain rollbackable instead of leaving unresolved prepared state.
-* Fix a rare corruption bug for tiered compaction that incorrectly moved last level range tombstones into proximal level. This corruption error is surfaced when force_consistency_checks is enabled.
-
-### Performance Improvements
-* Reduce the likelihood of user-facing metadata operations blocking on MANIFEST rotation when file creation is slow, such as on remote storage. MANIFEST write batches containing foreground edits from `CreateColumnFamily()`, `DropColumnFamily()`, `CreateColumnFamilyWithImport()`, `IngestExternalFile()`, and `DeleteFilesInRanges()` now get a relaxed file size threshold for triggering MANIFEST rotation; background-only MANIFEST write batches, such as compaction and flush, continue to use the normal threshold. This change should make auto-tuning manifest file size more attractive (see `max_manifest_file_size` and `max_manifest_space_amp_pct` options).
-
-
-## 11.3.0 (05/15/2026)
-### New Features
-* Add experimental DB option `async_wal_precreate` to precreate the next WAL file in a background thread and reduce foreground WAL rotation latency. The option is sanitized to false when WAL recycling is enabled.
-* Added a new `EventListener::OnCompactionPreCommit` callback that fires after a compaction job finishes but before its input files are released (i.e. while `FileMetaData::being_compacted` is still true). Listeners that maintain bookkeeping of which files are currently being compacted can clean up such state in this new callback to avoid races with concurrent compaction picking, where another thread might pick up the same files for a new compaction immediately after `being_compacted` is flipped back to false but before `OnCompactionCompleted` fires. The default implementation is a no-op so this is not a breaking change.
-* Add mutable DBOption `optimize_manifest_for_recovery` (default false). When enabled, RocksDB can reduce recovery work after a clean shutdown, which may lower DB::Open latency on warm reopens.
-* Added public utility APIs `ParseCompressionNameForDisplay()` to convert `TableProperties::compression_name` into a human-readable compression name for both legacy and format_version 7+ SST metadata, including custom `CompressionManager`-provided display names for custom compression types.
-* Add `reuse_manifest_on_open` DBOption (default false). When enabled, DB::Open reuses the existing MANIFEST file for append instead of creating a fresh one, avoiding the cost of serializing the entire database state into a new MANIFEST on the first post-open write. To prevent this feature from interfering with manifest file size auto-tuning, an extra forward-compatible field is now always added to the MANIFEST (to track the last "compacted" size).
-
-### Behavior Changes
-* Read-only open with `error_if_wal_file_exists=true` now tolerates empty WAL files so empty precreated WALs do not prevent inspection.
-* WriteCommitted TransactionDB now matches WritePrepared and WriteUnprepared compaction filtering in both single- and two-write-queue modes: a compaction filter's FilterMergeOperand will not be invoked on merge operands at or below the latest published sequence number.
-
-### Bug Fixes
-* Fixed blob-backed wide-column merge reads to preserve correct status
-propagation and resolution across memtable, read-only, and secondary DB
-paths.
-* Fixed a bug where `DB::GetCreationTimeOfOldestFile()` could return inaccurate results instead of the real creation time when called shortly after opening a legacy DB (one whose manifest lacks `file_creation_time`) with `open_files_async = true`. The API now waits for background SST file loading to complete only when needed; modern DBs are unaffected.
-* Fixed merge reads against wide-column/blob-backed base values to preserve precise failure statuses, including `GetMergeOperands()` and direct-write memtable reads.
-* Fix bug in range tombstone synthesis that covers live keys added during an IngestExternalFile
-* Reject the empty string as a column family name in `DB::CreateColumnFamily` / `DB::CreateColumnFamilies`. Previously such calls returned OK and a usable handle, but the column family was not persisted in the manifest, so any data written to it was silently lost on DB reopen.
-* Fixed a bug where a WriteCommitted TransactionDB using commit-bypass WBWI ingestion could drop an entry that is still visible at the published sequence boundary.
-
 ## 11.2.0 (04/18/2026)
 ### New Features
 * Added experimental `DBOptions::fast_sst_open` option. When enabled, RocksDB retrieves opaque file system metadata for SST files after flush, compaction, and external file ingestion, persists it in the MANIFEST, and passes it back to the file system on subsequent file opens to accelerate DB open time.
@@ -288,7 +288,7 @@ endif
 endif

 export JAVAC_ARGS
-CLEAN_FILES += rocksdb.pc
+CLEAN_FILES += make_config.mk rocksdb.pc

 ifeq ($(V), 1)
 $(info $(shell uname -a))
@@ -327,9 +327,6 @@ missing_make_config_paths := $(shell				\
 $(foreach path, $(missing_make_config_paths), \
 	$(warning Warning: $(path) does not exist))

-# This (the first rule) must depend on "all".
-default: all
-
 ifeq ($(PLATFORM), OS_AIX)
 # no debug info
 else ifneq ($(PLATFORM), IOS)
@@ -387,10 +384,6 @@ endif
 # TSAN doesn't work well with jemalloc. If we're compiling with TSAN, we should use regular malloc.
 ifdef COMPILE_WITH_TSAN
 	DISABLE_JEMALLOC=1
-	# Use a suppressions file instead of the process-wide TSAN default
-	# suppressions hook, which belongs to the final application.
-	TSAN_OPTIONS?=suppressions=$(CURDIR)/tools/tsan_suppressions.txt
-	export TSAN_OPTIONS
 	EXEC_LDFLAGS += -fsanitize=thread
 	PLATFORM_CCFLAGS += -fsanitize=thread -fPIC -DFOLLY_SANITIZE_THREAD
 	PLATFORM_CXXFLAGS += -fsanitize=thread -fPIC -DFOLLY_SANITIZE_THREAD
@@ -488,6 +481,9 @@ ifdef ROCKSDB_MODIFY_NPHASH
  PLATFORM_CXXFLAGS += -DROCKSDB_MODIFY_NPHASH=1
 endif

+# This (the first rule) must depend on "all".
+default: all
+
 WARNING_FLAGS = -W -Wextra -Wall -Wsign-compare -Wshadow \
  -Wunused-parameter

@@ -764,6 +760,7 @@ util/build_version.cc: $(filter-out $(OBJ_DIR)/util/build_version.o, $(LIB_OBJEC
 	$(AM_V_at)$(gen_build_version) > $@
 endif
 CLEAN_FILES += util/build_version.cc
+
 default: all

 #-----------------------------------------------
@@ -808,8 +805,7 @@ endif  # PLATFORM_SHARED_EXT
 .PHONY: check clean coverage ldb_tests package dbg gen-pc build_size \
 	release tags tags0 valgrind_check format static_lib shared_lib all \
 	rocksdbjavastatic rocksdbjava install install-static install-shared \
-	uninstall analyze tools tools_lib check-headers checkout_folly clang-tidy \
-	check-c-api-c_test
+	uninstall analyze tools tools_lib check-headers checkout_folly clang-tidy

 # Auto-configure git hooks on first build so developers do not need to run
 # "make install-hooks" manually. This is a no-op if already set.
@@ -887,43 +883,23 @@ coverage: clean
 parallel_tests = $(patsubst %,parallel_%,$(PARALLEL_TEST))
 .PHONY: gen_parallel_tests $(parallel_tests)
 # Shard size controls how many test cases run per process. The actual number
-# of shards per binary is: min(ceil(test_count / shard_size), NCORES * 8)
+# of shards per binary is: min(ceil(test_count / GTEST_SHARD_SIZE), NCORES * 8)
 # This adapts to machine size: many small shards on beefy machines, fewer
 # larger shards on CI (typically 2-4 cores).
 GTEST_SHARD_SIZE ?= 10
 NCORES ?= $(shell nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 4)

-# Per-binary overrides for GTEST_SHARD_SIZE, used to chop up binaries whose
-# individual test cases are slow enough that the default of 10 leaves one
-# shard on the critical path of "make check". Format: whitespace-separated
-# tokens "BINARY:SIZE". Sizes were tuned from `make suggest-slow-tests`
-# output to keep max shard time under ~20s on a beefy box. Reducing too far
-# adds per-shard fixed overhead, so don't use 1 unless individual tests are
-# >5s.
-SHARD_SIZE_OVERRIDES ?= \
-  point_lock_manager_stress_test:1 \
-  external_sst_file_test:1 \
-  external_sst_file_basic_test:2 \
-  db_test:3 \
-  compaction_service_test:1
-
 $(parallel_tests):
 	$(AM_V_at)TEST_BINARY=$(patsubst parallel_%,%,$@); \
  TEST_COUNT=` \
    (./$$TEST_BINARY --gtest_list_tests 2>/dev/null || echo "  list_failure") \
    | grep -c '^ '`; \
 	if [ "$$TEST_COUNT" -le 0 ]; then TEST_COUNT=1; fi; \
-	SHARD_SIZE=$(GTEST_SHARD_SIZE); \
-	for o in $(SHARD_SIZE_OVERRIDES); do \
-		case "$$o" in \
-			"$$TEST_BINARY":*) SHARD_SIZE=$${o#*:} ;; \
-		esac; \
-	done; \
 	MAX_SHARDS=$$(( $(NCORES) * 8 )); \
-	NUM_SHARDS=$$(( (TEST_COUNT + SHARD_SIZE - 1) / SHARD_SIZE )); \
+	NUM_SHARDS=$$(( (TEST_COUNT + $(GTEST_SHARD_SIZE) - 1) / $(GTEST_SHARD_SIZE) )); \
 	if [ "$$NUM_SHARDS" -gt "$$MAX_SHARDS" ]; then NUM_SHARDS=$$MAX_SHARDS; fi; \
 	if [ "$$NUM_SHARDS" -le 0 ]; then NUM_SHARDS=1; fi; \
-	echo "  Generating $$NUM_SHARDS shards for $$TEST_BINARY ($$TEST_COUNT tests, shard_size=$$SHARD_SIZE)"; \
+	echo "  Generating $$NUM_SHARDS shards for $$TEST_BINARY ($$TEST_COUNT tests)"; \
 	SHARD_IDX=0; \
 	while [ "$$SHARD_IDX" -lt "$$NUM_SHARDS" ]; do \
 		if [ -n "$(CI_TOTAL_SHARDS)" ] && [ $$(( $$SHARD_IDX % $(CI_TOTAL_SHARDS) )) -ne $(CI_SHARD_INDEX) ]; then \
@@ -949,64 +925,31 @@ gen_parallel_tests:
 	$(AM_V_at)$(FIND) t -type f -name 'run-*' -exec rm -f {} \;
 	$(MAKE) $(parallel_tests)

-# Reorder input lines (one per test or per shard) so the longest-running
-# tests/shards start first under "make check" parallel scheduling. The trick
-# is to prefix matched names with a fake duration (100), sort numerically
-# descending, then strip the prefix. Slow-matched tests therefore come ahead
-# of all unmatched tests; ordering within each group is unspecified.
+# Reorder input lines (which are one per test) so that the
+# longest-running tests appear first in the output.
+# Do this by prefixing each selected name with its duration,
+# sort the resulting names, and remove the leading numbers.
+# FIXME: the "100" we prepend is a fake time, for now.
+# FIXME: squirrel away timings from each run and use them
+# (when present) on subsequent runs to order these tests.
 #
-# Why this matters: gnu_parallel hands out jobs in input order. If a slow
-# test starts only after most others have finished, the run is bottlenecked
-# on its tail. Front-loading slow tests overlaps them with the bulk of
-# faster ones for much better wall-clock time.
+# Without this reordering, these two tests would happen to start only
+# after almost all other tests had completed, thus adding 100 seconds
+# to the duration of parallel "make check".  That's the difference
+# between 4 minutes (old) and 2m20s (new).
 #
-# Maintenance:
-#   1) Run `make check` so LOG is up-to-date.
-#   2) Run `make suggest-slow-tests` to see candidate slow binaries.
-#   3) Add binaries with high per-shard time (slow critical path) or high
-#      total time across many shards (need early queueing for fan-out).
-# Each alternative is wrapped in `^.*NAME.*$$` so the *whole input line* is
-# captured into $$1; then `s,(...),100 $$1,` prepends "100 " to the line.
+# 152.120 PASS t/DBTest.FileCreationRandomFailure
+# 107.816 PASS t/DBTest.EncodeDecompressedBlockSizeTest
 #
-# Tiers below are based on observed timings (see suggest-slow-tests).
-# Tier 1: max single-shard time >= 30s (critical-path bottlenecks).
-# Tier 2: max single-shard time 15-30s.
-# Tier 3: huge total time across many tiny shards; front-loading them keeps
-#         the tail of the run busy while big shards finish.
+# With sharded test execution, prioritize binaries known to be slow.
+# These generate many shards and should start early for good load balancing.
 slow_test_regexp = \
-	^.*point_lock_manager_stress_test.*$$|^.*db_test.*$$|^.*external_sst_file_test.*$$|^.*compaction_service_test.*$$|^.*corruption_test.*$$|^.*comparator_db_test.*$$|^.*external_sst_file_basic_test.*$$|^.*rate_limiter_test.*$$|^.*db_compaction_test.*$$|^.*write_prepared_transaction_test.*$$|^.*db_merge_operator_test.*$$|\
-	^.*db_dynamic_level_test.*$$|^.*db_bloom_filter_test.*$$|^.*error_handler_fs_test.*$$|^.*merge_helper_test.*$$|^.*transaction_test.*$$|^.*db_kv_checksum_test.*$$|^.*inlineskiplist_test.*$$|\
-	^.*db_with_timestamp_basic_test.*$$|^.*table_test.*$$|^.*db_wal_test.*$$|^.*block_based_table_reader_test.*$$|^.*block_test.*$$
+	^.*block_based_table_reader_test.*$$|^.*table_test.*$$|^.*block_test.*$$|^.*write_prepared_transaction_test.*$$|^.*transaction_test.*$$|^.*external_sst_file_test.*$$|^.*db_wal_test.*$$|^.*db_with_timestamp_basic_test.*$$|^.*db_test-.*$$
 prioritize_long_running_tests =						\
  perl -pe 's,($(slow_test_regexp)),100 $$1,'				\
    | sort -k1,1gr							\
    | sed 's/^[.0-9]* //'

-# Helper: print binaries observed to be slow in the last `make check` run.
-# Use this to decide whether `slow_test_regexp` above needs updating.
-# Aggregates per-binary across shards; flags any binary whose max single-shard
-# time is >= 20s OR whose total time is >= 200s.
-.PHONY: suggest-slow-tests
-suggest-slow-tests:
-	@if [ ! -s LOG ]; then \
-	  echo "No (or empty) LOG file. Run 'make check' first." >&2; exit 1; \
-	fi
-	@bash -c '$(quoted_perl_command)' < LOG | awk '\
-	  { \
-	    t=$$1; name=$$3; \
-	    sub(/^t\/run-/, "", name); \
-	    sub(/-shard-[0-9]+$$/, "", name); \
-	    total[name] += t; \
-	    if (t > max[name]) max[name] = t; \
-	    count[name]++; \
-	  } \
-	  END { \
-	    printf "%8s %8s %5s  %s\n", "TOTAL_s", "MAX_s", "SHRDS", "BINARY"; \
-	    for (n in total) \
-	      if (max[n] >= 20 || total[n] >= 200) \
-	        printf "%8.1f %8.1f %5d  %s\n", total[n], max[n], count[n], n; \
-	  }' | (read header; echo "$$header"; sort -k2,2gr)
-
 # "make check" uses
 # Run with "make J=1 check" to disable parallelism in "make check".
 # Run with "make J=200% check" to run two parallel jobs per core.
@@ -1043,7 +986,7 @@ check_0:
 		        awk -v s=$(CI_SHARD_INDEX) -v n=$(CI_TOTAL_SHARDS) '(NR-1)%n==s'; \
 		      else cat; fi; \
 		fi; \
-		$(FIND) t -name 'run-*' -print; \
+		find t -name 'run-*' -print; \
 	} \
 	  | $(prioritize_long_running_tests)				\
 	  | grep -E '$(tests-regexp)'					\
@@ -1065,7 +1008,7 @@ valgrind_check_0:
 	  '  run "make watch-log" in a separate window' '';		\
 	{								\
 	  printf './%s\n' $(filter-out $(PARALLEL_TEST) %skiplist_test options_settable_test, $(TESTS));		\
-	  $(FIND) t -name 'run-*' -print; \
+	  find t -name 'run-*' -print; \
 	}								\
 	  | $(prioritize_long_running_tests)				\
 	  | grep -E '$(tests-regexp)'					\
@@ -1127,89 +1070,8 @@ ifndef SKIP_FORMAT_BUCK_CHECKS
 	$(MAKE) check-buck-targets
 	$(MAKE) check-sources
 	$(MAKE) check-workflow-yaml
-	$(MAKE) check-c-api-gen
 endif

-# Check that the auto-generated C API files are up to date. It regenerates the
-# fragments and the inlined c.h/c.cc and compares them against a snapshot of the
-# checked-in copies (no net change when everything is up to date). It requires
-# clang++ (libclang, used to parse the C++ headers) and clang-format. When those
-# are unavailable the staleness/compat sub-checks are SKIPPED with a message so
-# `make check` still works without the codegen toolchain; the link-completeness
-# sub-check always runs (it needs no toolchain).
-#
-# Pin the formatter to match CI by setting CLANG_FORMAT_BINARY, e.g.:
-#   make check-c-api-gen CLANG_FORMAT_BINARY=clang-format-21
-# This target is part of `make check` and is skipped by SKIP_FORMAT_BUCK_CHECKS.
-#
-# Set CHECK_C_API_GEN_STRICT=1 to turn every "skip" below into a hard error, so a
-# core CI job that runs this target cannot silently regress to a no-op if a
-# prerequisite (clang++, or the compat baseline ref) goes missing. The dedicated
-# build-linux-clang-21-no_test_run CI job runs this target with the flag set.
-# Any non-empty value other than 0/no/false enables strict mode.
-CLANG_FORMAT_BINARY ?=
-# Backward-compatibility baseline for the C API (signature-level) check. CI
-# overrides this with the PR's merge target; locally it falls back to main /
-# origin/main and is skipped if neither resolves.
-API_COMPAT_REF ?= main
-CHECK_C_API_GEN_STRICT ?=
-check-c-api-gen:
-	# Link-completeness is a property of the checked-in c.h/c.cc and needs no
-	# clang toolchain, so it always runs: every declared public C API function
-	# must have exactly one definition (guards against dropped wrappers that
-	# would break downstream language bindings at link time).
-	$(PYTHON) tools/c_api_gen/check_api_completeness.py
-	# Backward-compatibility: no public C function may be removed or have its
-	# signature changed vs the baseline. Skipped if the baseline ref is not
-	# resolvable locally (CI passes an explicit ref), unless CHECK_C_API_GEN_STRICT.
-	@strict=""; case "$(CHECK_C_API_GEN_STRICT)" in ""|0|no|NO|false|FALSE) ;; *) strict=1 ;; esac; \
-	ref=""; \
-	if git rev-parse --verify --quiet "$(API_COMPAT_REF)^{commit}" >/dev/null; then ref="$(API_COMPAT_REF)"; \
-	elif git rev-parse --verify --quiet "origin/$(API_COMPAT_REF)^{commit}" >/dev/null; then ref="origin/$(API_COMPAT_REF)"; fi; \
-	if [ -n "$$ref" ]; then \
-	  $(PYTHON) tools/c_api_gen/check_api_compatibility.py --ref "$$ref"; \
-	elif [ -n "$$strict" ]; then \
-	  echo "ERROR: C API compat baseline '$(API_COMPAT_REF)' not resolvable and CHECK_C_API_GEN_STRICT is set" >&2; exit 1; \
-	else \
-	  echo "Skipping C API backward-compatibility check ($(API_COMPAT_REF) not found; set API_COMPAT_REF)"; \
-	fi
-	# Staleness: regenerate and confirm the checked-in output is current. Needs a
-	# clang++ (the generator parses C++ ASTs); detect one the way the generator
-	# does (a clang in $(CXX) -- which may be ccache-prefixed/versioned -- else a
-	# bare/versioned clang++ on PATH) rather than testing $(CXX) verbatim.
-	@strict=""; case "$(CHECK_C_API_GEN_STRICT)" in ""|0|no|NO|false|FALSE) ;; *) strict=1 ;; esac; \
-	cf_arg=""; \
-	if [ -n "$(CLANG_FORMAT_BINARY)" ]; then cf_arg="--clang-format $(CLANG_FORMAT_BINARY)"; fi; \
-	have_clang=""; \
-	for c in $$(printf '%s\n' $(CXX) | grep -i clang) clang++ clang++-21 clang++-20 clang++-19 clang++-18 clang++-17 clang++-16 clang++-15 clang++-14 clang++-13; do \
-	  if command -v "$$c" >/dev/null 2>&1; then have_clang=1; break; fi; \
-	done; \
-	if [ -n "$$have_clang" ]; then \
-	  $(PYTHON) tools/c_api_gen/verify_generated_up_to_date.py $$cf_arg; \
-	elif [ -n "$$strict" ]; then \
-	  echo "ERROR: no clang++ found and CHECK_C_API_GEN_STRICT is set; cannot run the C API staleness check" >&2; exit 1; \
-	else \
-	  echo "Skipping C API codegen staleness check (no clang++ found; install clang++ or set CXX to a clang to enable)"; \
-	fi
-
-# Quick local validation for C API generation plus the focused C API test.
-# This verifies the checked-in generated fragments as well as the inlined
-# include/rocksdb/c.h and db/c.cc outputs, then runs c_test in an isolated
-# TEST_TMPDIR to avoid stale-state failures.
-check-c-api-c_test:
-	$(PYTHON) tools/c_api_gen/verify_generated_up_to_date.py
-	$(MAKE) c_test
-	@tmpdir=$$(mktemp -d); \
-	  trap 'rm -rf "$$tmpdir"' EXIT; \
-	  echo "===== Running c_test with TEST_TMPDIR=$$tmpdir"; \
-	  if command -v timeout >/dev/null 2>&1; then \
-	    TEST_TMPDIR="$$tmpdir" timeout 60 ./c_test; \
-	  elif command -v gtimeout >/dev/null 2>&1; then \
-	    TEST_TMPDIR="$$tmpdir" gtimeout 60 ./c_test; \
-	  else \
-	    TEST_TMPDIR="$$tmpdir" ./c_test; \
-	  fi
-
 # TODO add ldb_tests
 check_some: $(ROCKSDBTESTS_SUBSET)
 	for t in $(ROCKSDBTESTS_SUBSET); do echo "===== Running $$t (`date`)"; ./$$t || exit 1; done
@@ -1359,32 +1221,16 @@ rocksdb.h rocksdb.cc: build_tools/amalgamate.py Makefile $(LIB_SOURCES) unity.cc
 	build_tools/amalgamate.py -I. -i./include unity.cc -x include/rocksdb/c.h -H rocksdb.h -o rocksdb.cc

 clean: clean-ext-libraries-all clean-rocks clean-rocksjava
-# Removed here rather than in clean-rocks (via CLEAN_FILES) so the build-parameter
-# auto-clean, which runs clean-rocks, doesn't delete the make_config.mk already
-# included by the in-progress make.
-	@rm -f make_config.mk

 clean-not-downloaded: clean-ext-libraries-bin clean-rocks clean-not-downloaded-rocksjava
-	@rm -f make_config.mk

 clean-rocks:
 # Not practical to exactly match all versions/variants in naming (e.g. debug or not)
-	@echo Removing link targets
-	@rm -f ${LIBNAME}*.so* ${LIBNAME}*.a $(BENCHMARKS) $(TOOLS) $(TESTS) $(PARALLEL_TEST) $(MICROBENCHS)
-	@echo Finding and cleaning other files
-	@rm -rf $(CLEAN_FILES) ios-x86 ios-arm scan_build_report
-	@if $(FIND) Makefile -regextype awk &> /dev/null; then \
-		$(FIND) . -regextype awk \
-			-regex '.*/([.].*|third-party)' -prune -o \
-			-type f -regex '.*[.]([oda]|gcda|gcno)' -exec rm -f {} \; ; \
-	else \
-		$(FIND) . -name "*.[oda]" -exec rm -f {} \; ; \
-	fi
-# Remove the build signature(s) LAST. Done after the object files are gone so
-# that a Ctrl+C partway through clean leaves the old signature in place: it
-# still matches the leftover objects, so a later build with different
-# parameters is still detected (signature usefulness is preserved).
-	@rm -f $(BUILD_SIG_FILE) jl/.build_signature jls/.build_signature
+	rm -f ${LIBNAME}*.so* ${LIBNAME}*.a
+	rm -f $(BENCHMARKS) $(TOOLS) $(TESTS) $(PARALLEL_TEST) $(MICROBENCHS)
+	rm -rf $(CLEAN_FILES) ios-x86 ios-arm scan_build_report
+	$(FIND) . -name "*.[oda]" -exec rm -f {} \;
+	$(FIND) . -type f \( -name "*.gcda" -o -name "*.gcno" \) -exec rm -f {} \;

 clean-rocksjava: clean-rocks
 	rm -rf jl jls
@@ -1397,7 +1243,7 @@ clean-ext-libraries-all:
 	rm -rf bzip2* snappy* zlib* lz4* zstd*

 clean-ext-libraries-bin:
-	$(FIND) . -maxdepth 1 -type d \( -name bzip2\* -or -name snappy\* -or -name zlib\* -or -name lz4\* -or -name zstd\* \) -prune -exec rm -rf {} \;
+	find . -maxdepth 1 -type d \( -name bzip2\* -or -name snappy\* -or -name zlib\* -or -name lz4\* -or -name zstd\* \) -prune -exec rm -rf {} \;

 tags:
 	ctags -R .
@@ -1675,7 +1521,7 @@ db_open_with_config_test: $(OBJ_DIR)/db/db_open_with_config_test.o $(TEST_LIBRAR
 db_test: $(OBJ_DIR)/db/db_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)

-db_etc2_test: $(OBJ_DIR)/db/db_etc2_test.o $(TEST_LIBRARY) $(LIBRARY)
+db_test2: $(OBJ_DIR)/db/db_test2.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)

 db_etc3_test: $(OBJ_DIR)/db/db_etc3_test.o $(TEST_LIBRARY) $(LIBRARY)
@@ -1690,6 +1536,12 @@ db_logical_block_size_cache_test: $(OBJ_DIR)/db/db_logical_block_size_cache_test
 db_blob_index_test: $(OBJ_DIR)/db/blob/db_blob_index_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)

+blog_format_test: $(OBJ_DIR)/db/blog/blog_format_test.o $(TEST_LIBRARY) $(LIBRARY)
+	$(AM_LINK)
+
+blog_writer_test: $(OBJ_DIR)/db/blog/blog_writer_test.o $(TEST_LIBRARY) $(LIBRARY)
+	$(AM_LINK)
+
 db_block_cache_test: $(OBJ_DIR)/db/db_block_cache_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)

@@ -2418,101 +2270,6 @@ ifeq ($(PLATFORM), OS_OPENBSD)
 endif
 export SHA256_CMD

-# ----------------------------------------------------------------------------
-# Build parameter change detection
-# ----------------------------------------------------------------------------
-# RocksDB writes object files to the same $(OBJ_DIR) paths regardless of
-# DEBUG_LEVEL, sanitizers (ASAN/TSAN/UBSAN), ASSERT_STATUS_CHECKED, RTTI, LTO,
-# COERCE_CONTEXT_SWITCH, etc.  Most of those are applied in this Makefile after
-# `include make_config.mk` and are therefore NOT reflected in make_config.mk,
-# so switching them and rebuilding silently mixes incompatible object files.
-# To guard against that, we hash the fully-resolved compile/link parameters
-# (which already embed make_config.mk via PLATFORM_*) and compare against the
-# value recorded from the previous build.  On mismatch the build stops so the
-# user can `make clean`.  Knobs:
-#   AUTO_CLEAN=1
-#     run `make clean-rocks` automatically on mismatch
-#   ALLOW_BUILD_PARAMETER_CHANGE=1
-#     skip the check entirely (e.g. intentionally mixing DEBUG_LEVEL=1 and
-#     DEBUG_LEVEL=2)
-# The signature is stored per-$(OBJ_DIR), so Java (jl/jls) builds are tracked
-# independently from the default build.
-BUILD_SIG_FILE := $(OBJ_DIR)/.build_signature
-# NOTE: deliberately NOT added to CLEAN_FILES. The signature is removed as the
-# very last step of clean-rocks so that an interrupted clean keeps it (see
-# clean-rocks), preserving change detection across a Ctrl+C'd clean.
-
-# Goals that do not compile object files into the tree (pure utilities,
-# informational, source/config checks): the change check is irrelevant for them.
-BUILD_SIG_NONBUILD_GOALS := \
-	clean clean-rocks clean-not-downloaded clean-rocksjava \
-	clean-not-downloaded-rocksjava clean-ext-libraries-all \
-	clean-ext-libraries-bin \
-	format format-auto check-format check-buck-targets check-headers \
-	check-sources check-workflow-yaml check-progress clang-tidy \
-	tags tags0 package jclean checkout_folly build_folly \
-	watch-log dump-log suggest-slow-tests list_all_tests gen-pc \
-	gen_parallel_tests check-c-api-gen \
-	setup-hooks install-hooks uninstall-hooks uninstall db_crashtest_tests
-# Goals that clean before building (depend on or invoke `clean`): they manage
-# their own freshness, so the check must not block them (it would error before
-# their built-in clean runs).
-BUILD_SIG_NONBUILD_GOALS += \
-	release coverage build_size analyze analyze_incremental \
-	asan_check asan_crash_test asan_crash_test_with_atomic_flush \
-	asan_crash_test_with_txn asan_crash_test_with_best_efforts_recovery \
-	whitebox_asan_crash_test blackbox_asan_crash_test \
-	ubsan_check ubsan_crash_test ubsan_crash_test_with_atomic_flush \
-	ubsan_crash_test_with_txn ubsan_crash_test_with_best_efforts_recovery \
-	whitebox_ubsan_crash_test blackbox_ubsan_crash_test
-
-# Goals that explicitly clean; never trip the check when one is requested.
-BUILD_SIG_CLEAN_GOALS := \
-	clean clean-rocks clean-not-downloaded clean-rocksjava \
-	clean-not-downloaded-rocksjava clean-ext-libraries-all \
-	clean-ext-libraries-bin
-
-BUILD_SIG_GOALS := $(if $(MAKECMDGOALS),$(MAKECMDGOALS),all)
-BUILD_SIG_DO_BUILD := $(filter-out $(BUILD_SIG_NONBUILD_GOALS),$(BUILD_SIG_GOALS))
-BUILD_SIG_CLEANING := $(filter $(BUILD_SIG_CLEAN_GOALS),$(MAKECMDGOALS))
-# Dry runs (-n/--just-print) must not write the stamp, clean, or error; the
-# parse-time $(shell) below would otherwise run even under -n. Note that
-# actual options are canonicalized and shorted as possible such that all
-# short options are in the first word of MAKEFLAGS.
-BUILD_SIG_DRYRUN := $(findstring n,$(firstword -$(MAKEFLAGS)))
-
-# Only enforce at the top level. Sub-makes (e.g. `check` invokes
-# $(MAKE) gen_parallel_tests / check-c-api-gen / check_0) inherit the parent's
-# build flags, so the top-level check already covers them; re-checking inside a
-# sub-make only causes spurious failures.
-ifneq ($(ALLOW_BUILD_PARAMETER_CHANGE),1)
-ifeq ($(MAKELEVEL),0)
-ifeq ($(BUILD_SIG_DRYRUN),)
-ifeq ($(BUILD_SIG_CLEANING),)
-ifneq ($(BUILD_SIG_DO_BUILD),)
-  BUILD_SIG := $(shell printf '%s' '$(CC)|$(CXX)|$(CFLAGS)|$(CXXFLAGS)|$(LDFLAGS)|$(EXEC_LDFLAGS)' | $(SHA256_CMD) | cut -d ' ' -f 1)
-  BUILD_SIG_OLD := $(shell cat $(BUILD_SIG_FILE) 2>/dev/null)
-  ifneq ($(BUILD_SIG_OLD),)
-  ifneq ($(BUILD_SIG_OLD),$(BUILD_SIG))
-  ifeq ($(AUTO_CLEAN),1)
-    $(info *** Build parameters changed since last build (OBJ_DIR=$(OBJ_DIR)); running 'make clean-rocks' because AUTO_CLEAN=1)
-    BUILD_SIG_CLEAN_OUTPUT := $(shell $(MAKE) clean-rocks 1>&2)
-    ifneq ($(.SHELLSTATUS),0)
-      $(error AUTO_CLEAN: 'make clean-rocks' failed (exit $(.SHELLSTATUS)); not building against a partially-cleaned tree)
-    endif
-  else
-    $(error Build parameters changed since the last build (OBJ_DIR=$(OBJ_DIR)). Existing object files are stale and must be removed. Run 'make clean', or set AUTO_CLEAN=1 to clean automatically, or ALLOW_BUILD_PARAMETER_CHANGE=1 to build anyway)
-  endif
-  endif
-  endif
-  # Record the current signature for the next build.
-  BUILD_SIG_WRITE := $(shell mkdir -p $(OBJ_DIR) 2>/dev/null; printf '%s\n' '$(BUILD_SIG)' > $(BUILD_SIG_FILE))
-endif
-endif
-endif
-endif
-endif
-
 zlib-$(ZLIB_VER).tar.gz:
 	curl --fail --output zlib-$(ZLIB_VER).tar.gz --location ${ZLIB_DOWNLOAD_BASE}/zlib-$(ZLIB_VER).tar.gz
 	ZLIB_SHA256_ACTUAL=`$(SHA256_CMD) zlib-$(ZLIB_VER).tar.gz | cut -d ' ' -f 1`; \
@@ -0,0 +1,318 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<title>Blog File Format Specification - RocksDB</title>
+<style>
+  body { font-family: 'Segoe UI', Arial, sans-serif; max-width: 960px; margin: 40px auto; padding: 0 20px; color: #222; line-height: 1.6; }
+  h1 { border-bottom: 3px solid #333; padding-bottom: 8px; }
+  h2 { border-bottom: 2px solid #999; padding-bottom: 4px; margin-top: 40px; }
+  h3 { margin-top: 30px; }
+  pre { background: #f4f4f4; border: 1px solid #ddd; border-radius: 4px; padding: 12px 16px; overflow-x: auto; font-size: 13px; line-height: 1.5; }
+  code { background: #f0f0f0; padding: 1px 5px; border-radius: 3px; font-size: 13px; }
+  table { border-collapse: collapse; width: 100%; margin: 16px 0; }
+  th, td { border: 1px solid #bbb; padding: 8px 12px; text-align: left; vertical-align: top; }
+  th { background: #e8e8e8; font-weight: 600; }
+  .diagram { background: #fafafa; border: 1px solid #ccc; border-radius: 4px; padding: 16px; margin: 16px 0; font-family: 'Courier New', monospace; font-size: 13px; white-space: pre; overflow-x: auto; line-height: 1.4; }
+  .note { background: #fff8e1; border-left: 4px solid #ffc107; padding: 10px 14px; margin: 14px 0; }
+  .decision { background: #e8f5e9; border-left: 4px solid #4caf50; padding: 10px 14px; margin: 14px 0; }
+</style>
+</head>
+<body>
+
+<h1>"Blog" File Format Specification</h1>
+<p><em>A unified file format for WAL, Blob, and related data in RocksDB</em></p>
+<p>Status: Implementation in progress &nbsp;|&nbsp; Format name: "blog" (portmanteau of "blob" + "log")</p>
+
+<!-- ======================================================================= -->
+<h2>Vocabulary</h2>
+
+<table>
+<tr><th>Term</th><th>Scope</th><th>Definition</th></tr>
+<tr><td><strong>Record</strong></td><td>Blog file</td><td>A top-level unit in the blog file body: blob record, WriteBatch record, preamble-start record, footer record.</td></tr>
+<tr><td><strong>Operation (op)</strong></td><td>WriteBatch</td><td>An entry within a WriteBatch: Put op, Delete op, Merge op, etc.</td></tr>
+<tr><td><strong>Compact format</strong></td><td>Record</td><td>A record with varint length &le; 3 bytes. Omits the type byte (type from header).</td></tr>
+<tr><td><strong>Full format</strong></td><td>Record</td><td>A record with varint length &gt; 3 bytes. Includes explicit type, pre-payload compression type, and prefix checksum.</td></tr>
+</table>
+
+<!-- ======================================================================= -->
+<h2 id="s1">File-Level Structure</h2>
+
+<p>A blog file consists of three regions: a <strong>fixed header</strong> with a <strong>property section</strong>, a <strong>body</strong> of records, and an optional <strong>footer</strong> composed of footer records.</p>
+
+<div class="diagram">
+---------------------------------------------------------------------+
+|                         FILE HEADER (40 bytes fixed)                 |
+|  96-bit magic, schema version, checksum type, compact record type,  |
+|  flags, escape sequence, reserved, property section size, checksum  |
+---------------------------------------------------------------------+
+|                    HEADER PROPERTY SECTION                           |
+|  Named key-value pairs + 5-byte trailer (compression + checksum)    |
+|  Followed by arbitrarily long padding (0x00 or 0xFF)                |
+---------------------------------------------------------------------+
+|                         FILE BODY                                    |
+|  Sequence of records, each starting with the escape sequence.       |
+|  Record types: blob, WriteBatch, preamble-start, footer records.    |
+---------------------------------------------------------------------+
+|                    FILE FOOTER (optional)                            |
+|  Footer index records (0xFD), footer properties record (0xFE),      |
+|  footer locator record (0xFF) -- must be last.                      |
+---------------------------------------------------------------------+</div>
+
+<h3>Fixed Header (40 bytes)</h3>
+
+<table>
+<tr><th>Offset</th><th>Size</th><th>Field</th></tr>
+<tr><td>0</td><td>12</td><td>File magic: <code>kBlogFileMagic</code> -- opaque 12 bytes ("Blog" ASCII + XXH3_64bits("Blog"))</td></tr>
+<tr><td>12</td><td>1</td><td>Schema version (currently 0). Newer versions are rejected by older readers.</td></tr>
+<tr><td>13</td><td>1</td><td>Checksum type (<code>ChecksumType</code> enum: 0=none, 1=CRC32c, 4=XXH3). Configured via <code>DBOptions::blog_checksum</code>.</td></tr>
+<tr><td>14</td><td>1</td><td>Compact record type (<code>BlogRecordType</code> -- type for all compact-format records)</td></tr>
+<tr><td>15</td><td>1</td><td>Flags: bit 0 = <code>kBlogFileRecycled</code> (file may contain trailing stale data)</td></tr>
+<tr><td>16</td><td>10</td><td>Escape sequence: bytes [0-5] random (byte[0] not 0x00/0xFF), bytes [6-9] = lower32(XXH3_64bits_withSeed(bytes[0-5], kBlogEscapeSeqSeed)). First 4 bytes also serve as incarnation ID (little-endian via DecodeFixed32).</td></tr>
+<tr><td>26</td><td>6</td><td>Reserved (zero)</td></tr>
+<tr><td>32</td><td>4</td><td>Property section size (uint32 LE) -- includes 5-byte trailer</td></tr>
+<tr><td>36</td><td>4</td><td>Fixed header checksum -- covers bytes [0, 36)</td></tr>
+</table>
+
+<h3>Header Property Section</h3>
+
+<p>Immediately follows the fixed header. Contains named key-value pairs encoded as:</p>
+<pre>[name_len: varint32] [name: name_len bytes] [value_len: varint32] [value: value_len bytes] ...</pre>
+<p>Followed by a 5-byte trailer: <code>[compression_type: 1B][checksum: 4B]</code> (same as block-based table). The checksum covers the property data + compression_type, with a context checksum modifier using the incarnation ID at offset <code>kBlogFileFixedHeaderSize</code>.</p>
+
+<p>After the property section, arbitrarily long padding (0x00 or 0xFF, differing from the last meaningful byte) aligns the first record's escape sequence. This supports stronger alignment requirements (flush/sync boundaries) or recycling files of all zeros.</p>
+
+<h3>Property Name Convention</h3>
+<table>
+<tr><th>First letter</th><th>Meaning</th></tr>
+<tr><td>Uppercase (e.g. <code>"CompressionCompatibilityName"</code>)</td><td><strong>Required</strong> -- reader must recognize or reject the file</td></tr>
+<tr><td>Lowercase (e.g. <code>"role"</code>)</td><td><strong>Ignorable</strong> -- reader may skip unrecognized properties</td></tr>
+</table>
+
+<h3>Known Header Properties</h3>
+<table>
+<tr><th>Name</th><th>Required?</th><th>Description</th></tr>
+<tr><td><code>"CompressionCompatibilityName"</code></td><td>Required (if any compression)</td><td>Compression manager compatibility name (e.g. "builtin_v2")</td></tr>
+<tr><td><code>"WriteBatchStreamingCompressionType"</code></td><td>Required (if streaming active)</td><td>2-digit hex of CompressionType for streaming WriteBatch compression (e.g. "07" for ZSTD). Presence means WriteBatch records with <code>kStreamingCompressionSentinel</code> (0x7F) trailer are part of a cross-record streaming context.</td></tr>
+<tr><td><code>"TimestampSize"</code></td><td>Required (if &gt;0)</td><td>Size of user timestamps</td></tr>
+<tr><td><code>"PredecessorWalInfo"</code></td><td>Required (if tracking)</td><td>Predecessor WAL metadata for verification</td></tr>
+<tr><td><code>"role"</code></td><td>Ignorable</td><td>File purpose hint: "wal", "blob", "rlog"</td></tr>
+<tr><td><code>"compressionSettings"</code></td><td>Ignorable</td><td>Human-readable compression settings for debugging</td></tr>
+<tr><td><code>"creationTime"</code></td><td>Ignorable</td><td>Unix timestamp of file creation</td></tr>
+<tr><td><code>"creator"</code></td><td>Ignorable</td><td>Host/process identifier for debugging</td></tr>
+</table>
+
+<!-- ======================================================================= -->
+<h2 id="s2">Escape Sequences</h2>
+
+<div class="decision">
+<strong>Decision:</strong> 10-byte escape sequence: 6 random bytes + 4 derived bytes. First byte not 0x00 nor 0xFF (distinguishable from padding). Bytes [6-9] = lower32(XXH3_64bits_withSeed(bytes[0-5], kBlogEscapeSeqSeed)), enabling heuristic detection without knowing the header.
+</div>
+
+<p>Escape sequences must be <strong>32-bit aligned</strong> in the file. The first 4 bytes (little-endian) serve as the <strong>incarnation ID</strong> for context checksums.</p>
+
+<h3>Primary Roles</h3>
+<ul>
+  <li><strong>WAL recycling detection:</strong> When recovery encounters undecodable data, scan for our escape sequence. If not found, the data is stale/recycled (different random sequence). The <code>kBlogFileRecycled</code> flag in the header indicates recycling is expected.</li>
+  <li><strong>Non-linear recovery:</strong> After corruption, scan forward for the next escape sequence to resume recovery (<code>kSkipAnyCorruptedRecords</code>).</li>
+  <li><strong>Record boundary discovery:</strong> Find record boundaries from any file position.</li>
+</ul>
+
+<!-- ======================================================================= -->
+<h2 id="s3">Record Types and Formats</h2>
+
+<h3>Record Type Values</h3>
+<table>
+<tr><th>Value</th><th>Name</th><th>Usage</th></tr>
+<tr><td colspan="3"><em>Body record types (0x01-0x7F)</em></td></tr>
+<tr><td>0x01</td><td><code>kBlogBlobRecord</code></td><td>Blob data (typically a separated value)</td></tr>
+<tr><td>0x02</td><td><code>kBlogPreambleStartRecord</code></td><td>Preamble marker (stub)</td></tr>
+<tr><td>0x03</td><td><code>kBlogWriteBatchRecord</code></td><td>Serialized WriteBatch</td></tr>
+<tr><td>0x04-0x7F</td><td></td><td><em>Reserved for future body record types</em></td></tr>
+<tr><td colspan="3"><em>Footer record types (0xF0-0xFF, in expected order of occurrence with gaps)</em></td></tr>
+<tr><td>0xF0</td><td><code>kBlogFooterIndexRecord</code></td><td>Large footer metadata (sparse index)</td></tr>
+<tr><td>0xF1-0xF3</td><td></td><td><em>Reserved for future footer data records</em></td></tr>
+<tr><td>0xF4-0xF7</td><td></td><td><em>Reserved for future footer data records</em></td></tr>
+<tr><td>0xF8</td><td><code>kBlogFooterPropertiesRecord</code></td><td>Small footer metadata (named properties)</td></tr>
+<tr><td>0xF9-0xFB</td><td></td><td><em>Reserved</em></td></tr>
+<tr><td>0xFC</td><td><code>kBlogFooterFileChecksumInfo</code></td><td>Full file checksum state dump. Allows inferring the file checksum from just reading the tail. Placeholder for future use.</td></tr>
+<tr><td>0xFD-0xFE</td><td></td><td><em>Reserved</em></td></tr>
+<tr><td>0xFF</td><td><code>kBlogFooterLocatorRecord</code></td><td>Footer locator with relative offsets. Must be the last record in the file.</td></tr>
+</table>
+
+<h3>Length Semantics</h3>
+<ul>
+  <li><code>length = 0</code>: No payload and no 5-byte trailer. Record is escape_seq + prefix fields + padding.</li>
+  <li><code>length &gt; 0</code>: Payload of <code>length</code> bytes followed by 5-byte trailer.</li>
+  <li><code>length = 2^63 - 1</code>: Unspecified size. Reader scans forward for next escape sequence.</li>
+</ul>
+
+<h3>Compact Record Format (varint length &le; 2 bytes, default record type)</h3>
+<div class="diagram">
+[escape_seq: 10B] [varint length: 1-2B]
+  [payload: length bytes]
+  [compression_type: 1B] [checksum: 4B]
+  [padding: 0+ B]</div>
+<p>No type byte -- type comes from the header's <code>compact_record_type</code> field. Used for payloads &lt; 16 KiB.</p>
+
+<h3>Full Record Format (varint length &gt; 2 bytes, or forced)</h3>
+<div class="diagram">
+[escape_seq: 10B] [varint length: 3+B] [type: 1B] [compression_type: 1B]
+  [prefix_checksum: 4B]
+  [payload: length bytes]     (if length &gt; 0)
+  [compression_type: 1B] [checksum: 4B]  (if length &gt; 0)
+  [padding: 0+ B]</div>
+<p>The <code>prefix_checksum</code> covers (varint + type + compression_type), with a context checksum modifier for defense-in-depth. Validates the length before attempting a potentially large read. The pre-payload <code>compression_type</code> enables streaming decompression without seeking to the trailer.</p>
+
+<p>Records that don't match the compact_record_type (e.g. footer records, preamble-start) always use full format by encoding the varint with &ge; 3 bytes (irregular encoding).</p>
+
+<p>All checksums in blog files (fixed header, property section trailer, record prefix, record trailer) use context checksum modifiers incorporating the incarnation ID, providing defense-in-depth for misplaced data detection even with <code>kNoChecksum</code>.</p>
+
+<!-- ======================================================================= -->
+<h2 id="s4">Compression</h2>
+
+<h3>Per-Record Compression</h3>
+<p>Each record's trailer <code>compression_type</code> byte indicates the compression algorithm used for that record's payload. The actual type comes from <code>Compressor::CompressBlock</code> output, not the configured type. This is the same approach used by SST block-based table builders.</p>
+
+<h3>Streaming Compression (WriteBatch records only)</h3>
+<p>When the header property <code>WriteBatchStreamingCompressionType</code> is set, WriteBatch record payloads may use streaming compression across records. Such records use <code>kStreamingCompressionSentinel</code> (0x7F) as their trailer's compression_type byte, indicating "compressed using the streaming algorithm declared in the header."</p>
+
+<p>A record with <code>kNoCompression</code> (0x00) in the trailer remains individually uncompressed even when streaming is active, enabling dynamic on/off switching based on compression effectiveness.</p>
+
+<p>Non-WriteBatch records (blob records, footer records) are always outside the streaming context and use per-record compression, keeping blob data randomly readable.</p>
+
+<div class="note">
+Currently only ZSTD is supported for streaming compression. The <code>WriteBatchStreamingCompressionType</code> property is required (uppercase first letter), so older readers that don't understand it will reject the file rather than misinterpret streaming-compressed payloads.
+</div>
+
+<!-- ======================================================================= -->
+<h2 id="s5">Padding Scheme</h2>
+
+<p>Padding fills the gap between a record's trailer (or the header property section) and the next escape sequence. The padding byte value is chosen to <strong>differ from the last meaningful byte</strong>, enabling unambiguous scanning.</p>
+
+<table>
+<tr><th>Last meaningful byte</th><th>Pad with</th><th>Mandatory?</th></tr>
+<tr><td><code>0x00</code></td><td><code>0xFF</code></td><td>Yes -- at least 1 byte required</td></tr>
+<tr><td><code>0xFF</code></td><td><code>0x00</code></td><td>Yes -- at least 1 byte required</td></tr>
+<tr><td>Anything else</td><td><code>0x00</code> (writer's choice)</td><td>Only if needed for alignment</td></tr>
+</table>
+
+<p>Padding may be arbitrarily long for stronger alignment requirements (e.g. flush/sync boundaries) or for recycling a file of all zeros. The reader skips padding by scanning forward over 0x00/0xFF bytes in 4-byte-aligned chunks until finding a byte that is neither, which is the first byte of the next escape sequence (guaranteed to be neither 0x00 nor 0xFF).</p>
+
+<!-- ======================================================================= -->
+<h2 id="s6">Context Checksums</h2>
+
+<div class="decision">
+<strong>Decision (adopted from SST format_version=6):</strong> Each record's checksum incorporates a 32-bit <strong>incarnation ID</strong> (first 4 bytes of the escape sequence). Uses <code>ChecksumModifierForContext(incarnation_id, record_offset)</code> -- the same mechanism as block-based SST files.
+</div>
+
+<p>Context checksums provide defense-in-depth for recycling detection and general data integrity verification with zero per-record overhead.</p>
+
+<p>The checksum type is configured from the CF's <code>BlockBasedTableOptions::checksum</code> setting (for blob files) or the default CF's setting (for WAL files). This is a reasonable but hopefully temporary way of configuring blog file internal checksums; a dedicated option may be added later.</p>
+
+<!-- ======================================================================= -->
+<h2 id="s7">Footer</h2>
+
+<p>The footer is composed of <strong>regular records</strong> using the full record format, maintaining simple forward parsability. A file is cleanly sealed when a valid footer locator record is the last record. Footer records appear in the order listed below.</p>
+
+<ol>
+  <li><strong>Footer index records</strong> (0xF0): Large metadata like sparse indexes for range queries. Zero or more per file.</li>
+  <li><strong>Footer properties record</strong> (0xF8): Named properties (same encoding as header properties, but the full record format's own trailer provides integrity). At most one per file.</li>
+  <li><strong>Footer file checksum info</strong> (0xFC): Placeholder for future use. Would contain a dump of the full file checksum state, allowing the file checksum to be inferred from just reading the tail of the file.</li>
+  <li><strong>Footer locator record</strong> (0xFF): Must be the <strong>last record</strong>. Contains relative offsets (in 4-byte units) to other footer records, sequential relative to each other in reverse order.</li>
+</ol>
+
+<h3>Footer Locator Payload</h3>
+<pre>[record_type: 1B] [relative_offset_in_4B_units: uint32 LE] ...</pre>
+<p>First entry: distance from locator's escape_seq backward to the preceding footer record. Subsequent: from the previous entry backward to the next.</p>
+
+<h3>Known Footer Properties</h3>
+<table>
+<tr><th>Name</th><th>Description</th></tr>
+<tr><td><code>"blobCount"</code></td><td>Number of blob records</td></tr>
+<tr><td><code>"totalBlobBytes"</code></td><td>Total uncompressed blob payload bytes</td></tr>
+<tr><td><code>"totalBlobBytesCompressed"</code></td><td>Total compressed blob payload bytes on disk</td></tr>
+<tr><td><code>"totalWriteBatchBytes"</code></td><td>Total uncompressed WriteBatch payload bytes</td></tr>
+<tr><td><code>"totalWriteBatchBytesCompressed"</code></td><td>Total compressed WriteBatch payload bytes on disk</td></tr>
+<tr><td><code>"minSequence"</code></td><td>Minimum sequence number</td></tr>
+<tr><td><code>"maxSequence"</code></td><td>Maximum sequence number</td></tr>
+</table>
+
+<!-- ======================================================================= -->
+<h2 id="s8">WAL Recovery Modes</h2>
+
+<p>The escape sequence is the <strong>primary mechanism</strong> for detecting WAL recycling and for non-linear data recovery. The <code>kBlogFileRecycled</code> flag in the header indicates the file may contain trailing stale data from a previous incarnation.</p>
+
+<table>
+<tr>
+  <th style="width:22%">Mode</th>
+  <th style="width:48%">Behavior on Undecodable Data</th>
+  <th style="width:30%">Escape Sequence Role</th>
+</tr>
+<tr>
+  <td><code>kAbsoluteConsistency</code></td>
+  <td>Error on any failure, including incomplete trailing records. If recycled and no escape sequence found in trailing data, accept as clean end.</td>
+  <td>Distinguishes stale recycled data from corruption.</td>
+</tr>
+<tr>
+  <td><code>kTolerateCorruptedTailRecords</code></td>
+  <td>Incomplete trailing record (Incomplete status): tolerate, stop at last complete record. Corruption: scan for escape sequence. Not found = clean end (recycled or preallocated). Found with valid record beyond = mid-file corruption (error).</td>
+  <td>Distinguishes tail damage from mid-file corruption.</td>
+</tr>
+<tr>
+  <td><code>kPointInTimeRecovery</code> (default)</td>
+  <td>Stop at first inconsistency. Incomplete trailing records tolerated. Recycled trailing data accepted.</td>
+  <td>Diagnostic improvement.</td>
+</tr>
+<tr>
+  <td><code>kSkipAnyCorruptedRecords</code></td>
+  <td>On corruption, scan forward for next escape sequence. If found, try to decode and verify; resume if valid. If not found, stop.</td>
+  <td>Essential for record discovery after corruption.</td>
+</tr>
+</table>
+
+<!-- ======================================================================= -->
+<h2 id="s9">WriteBatch Blob Preamble</h2>
+
+<p>A <strong>blob preamble</strong> is a sequence of blob records preceded by a preamble-start record (type 0x02, full format, length=0) and followed by the associated WriteBatch record. The blob records contain separated values referenced by <code>file_number = 0</code> blob references in the WriteBatch.</p>
+
+<p>This functionality is stubbed in the current implementation: the preamble-start record type is defined and can be written/read, but the full preamble flow (in-memory serialization, blob reference encoding) is deferred.</p>
+
+<!-- ======================================================================= -->
+<h2 id="s10">Replication Log Column Family (ShallowL0Store)</h2>
+
+<p>Deferred. The blog format supports a "rlog" role hint for replication log storage, with sparse indexes in footer records and in-memory index maintenance. See design notes in the original proposal.</p>
+
+<!-- ======================================================================= -->
+<h2 id="s11">Implementation Status</h2>
+
+<h3>Resolved (from original Open Questions)</h3>
+<table>
+<tr><th>Question</th><th>Resolution</th></tr>
+<tr><td>Escape sequence size</td><td>10 bytes: 6 random + 4 derived. First byte not 0x00/0xFF.</td></tr>
+<tr><td>Header/footer encoding</td><td>40-byte fixed header + named property section with 5-byte trailer. Footer uses regular full-format records: index (0xF0), properties (0xF8), file checksum info (0xFC, placeholder), locator (0xFF). Numbered in expected occurrence order with gaps for future types.</td></tr>
+<tr><td>Preamble-start record format</td><td>Full format, length=0, type 0x02. Minimal -- just the type tag.</td></tr>
+<tr><td>WriteBatch record framing</td><td>Same compact/full format as blob records, type 0x03.</td></tr>
+<tr><td>Compact vs full format</td><td>Compact: varint &le; 2B (payload &lt; 16 KiB), matches compact_record_type, no type byte. Full: varint &gt; 2B (possibly irregular), includes type + pre-payload compression_type + prefix_checksum with context modifier.</td></tr>
+<tr><td>Checksum context</td><td>All checksums (fixed header, property section, record prefix, record trailer) use context checksum modifiers with the incarnation ID, ensuring nonzero stored values even with <code>kNoChecksum</code>.</td></tr>
+<tr><td>Schema version</td><td>Starts at 0. Newer versions are rejected by older readers (returns <code>NotSupported</code>). Checksum is verified before schema version is checked.</td></tr>
+<tr><td>Streaming compression sentinel</td><td><code>kStreamingCompressionSentinel = 0x7F</code> defined in <code>CompressionType</code> enum (compression_type.h). Used in blog record trailers for streaming-compressed WriteBatch payloads.</td></tr>
+</table>
+
+<h3>DB Options</h3>
+<ul>
+  <li><code>use_blog_format_for_wals</code> (bool, default false): New WAL files use blog format.</li>
+  <li><code>use_blog_format_for_blobs</code> (bool, default false): New blob files use blog format.</li>
+  <li><code>blog_checksum</code> (<code>ChecksumType</code>, default <code>kXXH3</code>): Checksum algorithm for blog format files. <code>ChecksumType</code> enum moved to <code>include/rocksdb/checksum_type.h</code> (from <code>table.h</code>) for use by both table and DB options.</li>
+</ul>
+<p>All are immutable <code>DBOptions</code>. Existing legacy WAL and blob files are always readable regardless of these settings.</p>
+
+<h3>Compression Manager Integration</h3>
+<ul>
+  <li><strong>Blog blob files</strong> use the CF's configured compression manager (via <code>MutableCFOptions::compression_manager</code>). Legacy blob files continue to use the builtin manager for backward compatibility.</li>
+  <li><strong>Blog WAL files</strong> use per-record compression via <code>Compressor::CompressBlock</code>. The actual <code>CompressionType</code> from <code>CompressBlock</code> output is stored in the record trailer.</li>
+  <li>Streaming compression infrastructure exists (<code>WriteBatchStreamingCompressionType</code> property, <code>kStreamingCompressionSentinel</code> 0x7F trailer value) but is not yet enabled by default.</li>
+</ul>
+
+</body>
+</html>
@@ -360,7 +360,6 @@ def generate_buck(repo_path, deps_map):
                        extra_compiler_flags=json.dumps(deps["extra_compiler_flags"]),
                    )
    BUCK.export_file("tools/db_crashtest.py")
-    BUCK.export_file("tools/fault_injection_log_parser.py")

    print(ColorString.info("Generated BUCK Summary:"))
    print(ColorString.info("- %d libs" % BUCK.total_lib))
@@ -118,12 +118,6 @@ class TARGETSBuilder:
        self.total_bin = self.total_bin + 1

    def add_c_test(self):
-        # The actual c_test_bin target is defined by add_c_test_wrapper in the
-        # internal //rocks/buckifier:defs.bzl (not in this OSS repo). db/c_test.c
-        # #includes the generated c_api_gen/*.inc fragments, so under Buck's
-        # hermetic sandbox that wrapper must expose them as headers, e.g.
-        #   headers = native.glob(["c_api_gen/**/*.inc"])
-        # (Make/CMake resolve the include via -I. / PROJECT_SOURCE_DIR.)
        with open(self.path, "ab") as targets_file:
            targets_file.write(
                b"""
@@ -27,6 +27,7 @@
 #       -DLZ4                       if the LZ4 library is present
 #       -DZSTD                      if the ZSTD library is present
 #       -DNUMA                      if the NUMA library is present
+#       -DTBB                       if the TBB library is present
 #       -DMEMKIND                   if the memkind library is present
 #
 # Using gflags in rocksdb:
@@ -423,6 +424,19 @@ EOF
        fi
    fi

+    if ! test $ROCKSDB_DISABLE_TBB; then
+        # Test whether tbb is available
+        $CXX $PLATFORM_CXXFLAGS $LDFLAGS -x c++ - -o test.o -ltbb 2>/dev/null  <<EOF
+          #include <tbb/tbb.h>
+          int main() {}
+EOF
+        if [ "$?" = 0 ]; then
+            COMMON_FLAGS="$COMMON_FLAGS -DTBB"
+            PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -ltbb"
+            JAVA_LDFLAGS="$JAVA_LDFLAGS -ltbb"
+        fi
+    fi
+
    if ! test $ROCKSDB_DISABLE_JEMALLOC; then
        # Test whether jemalloc is available
        if echo 'int main() {}' | $CXX $PLATFORM_CXXFLAGS $LDFLAGS -x c++ - -o test.o -ljemalloc \
@@ -1,8 +1,5 @@
 #!/usr/bin/env bash
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# This source code is licensed under both the GPLv2 (found in the
-# COPYING file in the root directory) and Apache 2.0 License
-# (found in the LICENSE.Apache file in the root directory).
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved.
 #
 # Check for some simple mistakes in public headers (on the command line)
 # that should prevent commit or push
@@ -37,7 +37,7 @@ if [ "$?" != "1" ]; then
  BAD=1
 fi

-LC_ALL=C git grep -n $'[\x80-\xff]' -- ':!docs' ':!*.md' ':!.github'
+git grep -n -P "[\x80-\xFF]" -- ':!docs' ':!*.md'
 if [ "$?" != "1" ]; then
  echo '^^^^ Use only ASCII characters in source files'
  BAD=1
@@ -1,20 +1,21 @@
 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
 # The file is generated using update_dependencies.sh.
-GCC_BASE=/mnt/gvfs/third-party2/gcc/e9cb2d4550b5a95024125084420342d256b349cd/11.x/centos9-native/3bed279
-CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/4e46e6967e15412702e51960c69790a78933856f/21/platform010/72a2ff8
-LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/63c5179edc90fec473e53c1b2f92269c65c39e07/11.x/platform010/5684a5a
-GLIBC_BASE=/mnt/gvfs/third-party2/glibc/b4a6248a76a163bcccb1e4751e247712c535846e/2.34/platform010/f259413
-SNAPPY_BASE=/mnt/gvfs/third-party2/snappy/ef895164499fdfedb9d9b9c85520de10aa8ff9ca/1.1.8/platform010/76ebdda
-ZLIB_BASE=/mnt/gvfs/third-party2/zlib/643dbf0136f869562485cfcb2953f5cab60447ef/1.2.8/platform010/76ebdda
+GCC_BASE=/mnt/gvfs/third-party2/gcc/62de5a92e5f23c661c3d4b9f322e04eb14e7a5bd/11.x/centos8-native/886b5eb
+CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/1f6edd1ff15c99c861afc8f3cd69054cd974dd64/15/platform010/72a2ff8
+LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/d1129753c8361ac8e9453c0f4291337a4507ebe6/11.x/platform010/5684a5a
+GLIBC_BASE=/mnt/gvfs/third-party2/glibc/fed6e93d87571fb162734c86636119d45a398963/2.34/platform010/f259413
+SNAPPY_BASE=/mnt/gvfs/third-party2/snappy/31a346126a1f3b64812c362511cb04cc1bd40855/1.1.8/platform010/76ebdda
+ZLIB_BASE=/mnt/gvfs/third-party2/zlib/0c65c05468b5a38cef1a106a1f526463e120c8dd/1.2.8/platform010/76ebdda
 BZIP2_BASE=/mnt/gvfs/third-party2/bzip2/09703139cfc376bd8a82642385a0e97726b28287/1.0.6/platform010/76ebdda
-LZ4_BASE=/mnt/gvfs/third-party2/lz4/823bf8e000654abef784311296ffc8166d9d3986/1.9.4/platform010/76ebdda
-ZSTD_BASE=/mnt/gvfs/third-party2/zstd/0cda78647b5712bec7ec6d9ba2f0dcdabfb6f44f/1.4.x/platform010/64091f4
-GFLAGS_BASE=/mnt/gvfs/third-party2/gflags/a02e0de00945729ad553c187c64e86b57f45a33b/2.2.0/platform010/76ebdda
-JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/a1a50742bec7195bfafb594e174ea45dc197a420/master/platform010/779a252
+LZ4_BASE=/mnt/gvfs/third-party2/lz4/ff23d17b932725cc1734a14896a8b67c518ba169/1.9.4/platform010/76ebdda
+ZSTD_BASE=/mnt/gvfs/third-party2/zstd/576397d8b1d9cea7306ad1e454d5e55caaa2ff1c/1.4.x/platform010/64091f4
+GFLAGS_BASE=/mnt/gvfs/third-party2/gflags/fecac07861cb829f5e60dbeff0503d3272db73c0/2.2.0/platform010/76ebdda
+JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/0bb3f5756788ce26e2e16a1cb2f2af2c59b51abe/master/platform010/f57cc4a
 NUMA_BASE=/mnt/gvfs/third-party2/numa/5b602edd46fda54cdd7ea45f77dbe4061206e174/2.0.11/platform010/76ebdda
-LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/f3cce2e1a79ac8d64e102886603a6997d6e88640/1.8/platform010/76ebdda
+LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/97cac22a149c2e202917e05d44e87e516b68216f/1.4/platform010/5074a48
+TBB_BASE=/mnt/gvfs/third-party2/tbb/53953ebc4e3eda85ad6fc3e429ba146035e97b90/2018_U5/platform010/76ebdda
 LIBURING_BASE=/mnt/gvfs/third-party2/liburing/a98e2d137007e3ebf7f33bd6f99c2c56bdaf8488/20210212/platform010/76ebdda
 BENCHMARK_BASE=/mnt/gvfs/third-party2/benchmark/780c7a0f9cf0967961e69ad08e61cddd85d61821/trunk/platform010/76ebdda
-KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/0883cccda758e68b47e4c04e4fa01142e1f60f32/fb/platform010/da39a3e
-BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/1d5d19135a406a941d3a441eb2bf506bb9d19210/2.43/centos9-native/be7139e
-VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/3e2b7ccc315c9a0f2b678ce6fd774f4970f9bf3b/3.22.0/platform010/76ebdda
+KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/624a2f8f6c93c3c1df8aa4a6255d8202631a6c80/fb/platform010/da39a3e
+BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/39579e8603b48b3540f8b0633f43adf29acccb8b/2.37/centos8-native/da39a3e
+VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/cd9cc656d49ecb53797ce4d055e49fde29fd57ff/3.19.0/platform010/76ebdda
@@ -87,6 +87,15 @@ if test -z $PIC_BUILD; then
  LIBUNWIND="$LIBUNWIND_BASE/lib/libunwind.a"
 fi

+# location of TBB
+TBB_INCLUDE=" -isystem $TBB_BASE/include/"
+if test -z $PIC_BUILD; then
+  TBB_LIBS="$TBB_BASE/lib/libtbb.a"
+else
+  TBB_LIBS="$TBB_BASE/lib/libtbb_pic.a"
+fi
+CFLAGS+=" -DTBB"
+
 test "$USE_SSE" || USE_SSE=1
 export USE_SSE
 test "$PORTABLE" || PORTABLE=1
@@ -95,7 +104,7 @@ export PORTABLE
 BINUTILS="$BINUTILS_BASE/bin"
 AR="$BINUTILS/ar"

-DEPS_INCLUDE="$SNAPPY_INCLUDE $ZLIB_INCLUDE $BZIP_INCLUDE $LZ4_INCLUDE $ZSTD_INCLUDE $GFLAGS_INCLUDE $NUMA_INCLUDE"
+DEPS_INCLUDE="$SNAPPY_INCLUDE $ZLIB_INCLUDE $BZIP_INCLUDE $LZ4_INCLUDE $ZSTD_INCLUDE $GFLAGS_INCLUDE $NUMA_INCLUDE $TBB_INCLUDE"

 STDLIBS="-L $GCC_BASE/lib64"

@@ -141,17 +150,17 @@ CFLAGS+=" $DEPS_INCLUDE"
 CFLAGS+=" -DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX -DROCKSDB_FALLOCATE_PRESENT -DROCKSDB_MALLOC_USABLE_SIZE -DROCKSDB_RANGESYNC_PRESENT -DROCKSDB_SCHED_GETCPU_PRESENT"
 CXXFLAGS+=" $CFLAGS"

-EXEC_LDFLAGS=" $SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $NUMA_LIB"
+EXEC_LDFLAGS=" $SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $NUMA_LIB $TBB_LIBS"
 EXEC_LDFLAGS+=" -B$BINUTILS/gold"
 EXEC_LDFLAGS+=" -Wl,--dynamic-linker,/usr/local/fbcode/gcc-5-glibc-2.23/lib/ld.so"
 EXEC_LDFLAGS+=" $LIBUNWIND"
 EXEC_LDFLAGS+=" -Wl,-rpath=/usr/local/fbcode/gcc-5-glibc-2.23/lib"
-# dynamic loading
+# required by libtbb
 EXEC_LDFLAGS+=" -ldl"

 PLATFORM_LDFLAGS="$LIBGCC_LIBS $GLIBC_LIBS $STDLIBS -lgcc -lstdc++"

-EXEC_LDFLAGS_SHARED="$SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS"
+EXEC_LDFLAGS_SHARED="$SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $TBB_LIBS"

 VALGRIND_VER="$VALGRIND_BASE/bin/"

@@ -82,6 +82,11 @@ CFLAGS+=" -DNUMA"
 # location of libunwind
 LIBUNWIND="$LIBUNWIND_BASE/lib/libunwind${MAYBE_PIC}.a"

+# location of TBB
+TBB_INCLUDE=" -isystem $TBB_BASE/include/"
+TBB_LIBS="$TBB_BASE/lib/libtbb${MAYBE_PIC}.a"
+CFLAGS+=" -DTBB"
+
 # location of LIBURING
 LIBURING_INCLUDE=" -isystem $LIBURING_BASE/include/"
 LIBURING_LIBS="$LIBURING_BASE/lib/liburing${MAYBE_PIC}.a"
@@ -96,7 +101,7 @@ BINUTILS="$BINUTILS_BASE/bin"
 AR="$BINUTILS/ar"
 AS="$BINUTILS/as"

-DEPS_INCLUDE="$SNAPPY_INCLUDE $ZLIB_INCLUDE $BZIP_INCLUDE $LZ4_INCLUDE $ZSTD_INCLUDE $GFLAGS_INCLUDE $NUMA_INCLUDE $LIBURING_INCLUDE $BENCHMARK_INCLUDE"
+DEPS_INCLUDE="$SNAPPY_INCLUDE $ZLIB_INCLUDE $BZIP_INCLUDE $LZ4_INCLUDE $ZSTD_INCLUDE $GFLAGS_INCLUDE $NUMA_INCLUDE $TBB_INCLUDE $LIBURING_INCLUDE $BENCHMARK_INCLUDE"

 STDLIBS="-L $GCC_BASE/lib64"

@@ -152,18 +157,18 @@ CFLAGS+=" $DEPS_INCLUDE"
 CFLAGS+=" -DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX -DROCKSDB_FALLOCATE_PRESENT -DROCKSDB_MALLOC_USABLE_SIZE -DROCKSDB_RANGESYNC_PRESENT -DROCKSDB_SCHED_GETCPU_PRESENT -DROCKSDB_IOURING_PRESENT"
 CXXFLAGS+=" $CFLAGS"

-EXEC_LDFLAGS=" $SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $NUMA_LIB $LIBURING_LIBS $BENCHMARK_LIBS"
+EXEC_LDFLAGS=" $SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $NUMA_LIB $TBB_LIBS $LIBURING_LIBS $BENCHMARK_LIBS"
 EXEC_LDFLAGS+=" -Wl,--dynamic-linker,/usr/local/fbcode/platform010/lib/ld.so"
 EXEC_LDFLAGS+=" $LIBUNWIND"
 EXEC_LDFLAGS+=" -Wl,-rpath=/usr/local/fbcode/platform010/lib"
 EXEC_LDFLAGS+=" -Wl,-rpath=$GCC_BASE/lib64"
-# dynamic loading
+# required by libtbb
 EXEC_LDFLAGS+=" -ldl"

 PLATFORM_LDFLAGS="$LIBGCC_LIBS $GLIBC_LIBS $STDLIBS -lgcc -lstdc++"
 PLATFORM_LDFLAGS+=" -B$BINUTILS"

-EXEC_LDFLAGS_SHARED="$SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $LIBURING_LIBS $BENCHMARK_LIBS"
+EXEC_LDFLAGS_SHARED="$SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $TBB_LIBS $LIBURING_LIBS $BENCHMARK_LIBS"

 VALGRIND_VER="$VALGRIND_BASE/bin/"

@@ -1,188 +1,62 @@
 #!/usr/bin/env python3
-#  Copyright (c) Meta Platforms, Inc. and affiliates.
-#  This source code is licensed under both the GPLv2 (found in the COPYING file in the root directory)
-#  and the Apache 2.0 License (found in the LICENSE.Apache file in the root directory).
 """
 Pre-download packages with unreliable mirrors using fallback mirrors.
 Reads package info from folly's getdeps manifest files.
 """
-import configparser
-import hashlib
-import os
-import shutil
 import sys
-import urllib.request
-
-DOWNLOAD_TIMEOUT_SECONDS = 120
-DOWNLOAD_CHUNK_BYTES = 64 * 1024
-MAX_DOWNLOAD_BYTES = 50 * 1024 * 1024
-
-MIRROR_FALLBACKS = {
-    "ftpmirror.gnu.org/gnu/": [
-        "https://mirrors.kernel.org/gnu/",
-        "https://ftpmirror.gnu.org/gnu/",
-        "https://ftp.gnu.org/gnu/",
-    ],
-    "ftp.gnu.org/gnu/": [
-        "https://mirrors.kernel.org/gnu/",
-        "https://ftpmirror.gnu.org/gnu/",
-        "https://ftp.gnu.org/gnu/",
-    ],
-}
-
-# These packages must have URLs matching MIRROR_FALLBACKS; other packages are
-# left for getdeps.py's normal download path.
-PACKAGES_TO_CHECK = ("autoconf", "automake", "libtool", "libiberty")
-
+import os
+import hashlib
+import subprocess
+import configparser

 def sha256_file(path):
    """Calculate SHA256 hash of a file."""
    h = hashlib.sha256()
    try:
-        with open(path, "rb") as f:
-            for chunk in iter(lambda: f.read(65536), b""):
+        with open(path, 'rb') as f:
+            for chunk in iter(lambda: f.read(65536), b''):
                h.update(chunk)
        return h.hexdigest()
    except Exception:
        return None

-
 def parse_manifest(manifest_path):
    """Parse a getdeps manifest file to extract download info."""
-    # folly manifests can contain bare keys in sections unrelated to downloads.
-    config = configparser.ConfigParser(allow_no_value=True, interpolation=None)
+    config = configparser.ConfigParser()
    try:
-        with open(manifest_path, encoding="utf-8") as manifest_file:
-            config.read_file(manifest_file)
-    except Exception as ex:
-        print(f"  {os.path.basename(manifest_path)}: WARNING - parse failed: {ex}")
-        return None
-
-    if "download" in config:
-        return {
-            "url": config["download"].get("url", ""),
-            "sha256": config["download"].get("sha256", ""),
-        }
-    return None
-
-
-def file_size(path):
-    try:
-        return os.path.getsize(path)
+        config.read(manifest_path)
+        if 'download' in config:
+            return {
+                'url': config['download'].get('url', ''),
+                'sha256': config['download'].get('sha256', ''),
+            }
    except Exception:
-        return None
-
+        pass
+    return None

 def get_fallback_mirrors(url):
    """Get fallback mirror URLs for a given URL."""
-    for pattern, mirrors in MIRROR_FALLBACKS.items():
+    # Fallback mirror patterns for known unreliable hosts
+    mirror_fallbacks = {
+        "ftp.gnu.org/gnu/": [
+            "https://mirrors.kernel.org/gnu/",
+            "https://ftpmirror.gnu.org/gnu/",
+            "https://ftp.gnu.org/gnu/",
+        ],
+        "ftpmirror.gnu.org/gnu/": [
+            "https://mirrors.kernel.org/gnu/",
+            "https://ftpmirror.gnu.org/gnu/",
+            "https://ftp.gnu.org/gnu/",
+        ],
+    }
+
+    for pattern, mirrors in mirror_fallbacks.items():
        if pattern in url:
            # Extract the path after the pattern
            path_start = url.find(pattern) + len(pattern)
            path = url[path_start:]
            return [mirror + path for mirror in mirrors]
-    return []
-
-
-def download_url(url, filepath):
-    """Download URL to filepath without leaving partial files behind."""
-    tmp_filepath = filepath + ".tmp"
-    if os.path.exists(tmp_filepath):
-        os.remove(tmp_filepath)
-
-    request = urllib.request.Request(
-        url, headers={"User-Agent": "rocksdb-getdeps-fallback/1.0"}
-    )
-    try:
-        with urllib.request.urlopen(
-            request, timeout=DOWNLOAD_TIMEOUT_SECONDS
-        ) as response, open(tmp_filepath, "wb") as output:
-            copied = 0
-            while True:
-                chunk = response.read(DOWNLOAD_CHUNK_BYTES)
-                if not chunk:
-                    break
-
-                copied += len(chunk)
-                if copied > MAX_DOWNLOAD_BYTES:
-                    raise Exception(
-                        f"download exceeds {MAX_DOWNLOAD_BYTES} bytes"
-                    )
-                output.write(chunk)
-        os.replace(tmp_filepath, filepath)
-    finally:
-        if os.path.exists(tmp_filepath):
-            os.remove(tmp_filepath)
-
-
-def prepare_download(package, info, download_dir, cache_dir):
-    url = info["url"]
-    expected_sha256 = info["sha256"]
-    mirrors = get_fallback_mirrors(url)
-    if not mirrors:
-        return False
-
-    if not expected_sha256:
-        print(f"  {package}: WARNING - skipped fallback without sha256")
-        return False
-
-    # getdeps uses format: {package}-{filename}
-    filename = f"{package}-{os.path.basename(url)}"
-    filepath = os.path.join(download_dir, filename)
-    cache_path = os.path.join(cache_dir, filename)
-
-    # Check if already valid.
-    actual_sha256 = sha256_file(filepath) if os.path.exists(filepath) else None
-    if actual_sha256 == expected_sha256:
-        print(f"  {filename}: OK (already downloaded)")
-        return True
-    if actual_sha256 is not None:
-        print(
-            f"  {filename}: WARNING - removing invalid download "
-            f"sha256={actual_sha256}"
-        )
-        os.remove(filepath)
-
-    # The cache is only an opportunistic single-build accelerator; callers
-    # should not share it across concurrent builds without external locking.
-    actual_sha256 = sha256_file(cache_path) if os.path.exists(cache_path) else None
-    if actual_sha256 == expected_sha256:
-        print(f"  {filename}: OK (from cache)")
-        shutil.copy2(cache_path, filepath)
-        return True
-    if actual_sha256 is not None:
-        print(
-            f"  {filename}: WARNING - removing invalid cache "
-            f"sha256={actual_sha256}"
-        )
-        os.remove(cache_path)
-
-    # Try fallback mirrors.
-    for mirror_url in mirrors:
-        print(f"  {filename}: trying {mirror_url}...")
-        try:
-            download_url(mirror_url, filepath)
-        except Exception as ex:
-            print(f"  {filename}: WARNING - download failed: {ex}")
-            continue
-
-        actual_sha256 = sha256_file(filepath)
-        if actual_sha256 == expected_sha256:
-            size = file_size(filepath)
-            print(f"  {filename}: OK (downloaded, {size} bytes)")
-            shutil.copy2(filepath, cache_path)
-            return True
-
-        size = file_size(filepath)
-        print(
-            f"  {filename}: WARNING - sha256 mismatch from {mirror_url}: "
-            f"expected={expected_sha256} actual={actual_sha256} size={size}"
-        )
-        os.remove(filepath)
-
-    print(f"  {filename}: WARNING - all mirrors failed")
-    return False
-
+    return [url]  # No fallback, use original

 def main():
    if len(sys.argv) != 4:
@@ -190,39 +64,60 @@ def main():
        sys.exit(1)

    download_dir, cache_dir, manifests_dir = sys.argv[1], sys.argv[2], sys.argv[3]
-    os.makedirs(download_dir, exist_ok=True)
-    os.makedirs(cache_dir, exist_ok=True)

-    checked = 0
-    ready = 0
-    for package in PACKAGES_TO_CHECK:
+    # Packages known to have unreliable mirrors
+    packages_to_check = ["autoconf", "automake", "libtool"]
+
+    for package in packages_to_check:
        manifest_path = os.path.join(manifests_dir, package)
-        if not os.path.isfile(manifest_path):
+        if not os.path.exists(manifest_path):
            continue

        info = parse_manifest(manifest_path)
-        if not info or not info["url"]:
+        if not info or not info['url'] or not info['sha256']:
            continue

-        if not info["sha256"]:
-            print(f"  {package}: WARNING - skipped fallback without sha256")
+        # Determine filename from URL
+        url = info['url']
+        expected_sha256 = info['sha256']
+        url_filename = os.path.basename(url)
+
+        # getdeps uses format: {package}-{filename}
+        filename = f"{package}-{url_filename}"
+        filepath = os.path.join(download_dir, filename)
+        cache_path = os.path.join(cache_dir, filename)
+
+        # Check if already valid
+        if os.path.exists(filepath) and sha256_file(filepath) == expected_sha256:
+            print(f"  {filename}: OK (already downloaded)")
            continue

-        if not get_fallback_mirrors(info["url"]):
-            print(
-                f"  {package}: WARNING - skipped fallback without known mirror "
-                f"for {info['url']}"
-            )
+        # Check cache
+        if os.path.exists(cache_path) and sha256_file(cache_path) == expected_sha256:
+            print(f"  {filename}: OK (from cache)")
+            subprocess.run(['cp', cache_path, filepath], check=True)
            continue

-        checked += 1
-        try:
-            if prepare_download(package, info, download_dir, cache_dir):
-                ready += 1
-        except Exception as ex:
-            print(f"  {package}: WARNING - fallback preparation failed: {ex}")
+        # Try fallback mirrors
+        mirrors = get_fallback_mirrors(url)
+        downloaded = False
+        for mirror_url in mirrors:
+            print(f"  {filename}: trying {mirror_url}...")
+            try:
+                subprocess.run(['wget', '-q', '-O', filepath, mirror_url], check=True, timeout=120)
+                if sha256_file(filepath) == expected_sha256:
+                    print(f"  {filename}: OK (downloaded)")
+                    subprocess.run(['cp', filepath, cache_path], check=False)
+                    downloaded = True
+                    break
+                else:
+                    os.remove(filepath)
+            except Exception:
+                if os.path.exists(filepath):
+                    os.remove(filepath)

-    print(f"  fallback mirror downloads ready: {ready}/{checked}")
+        if not downloaded:
+            print(f"  {filename}: WARNING - all mirrors failed")

 if __name__ == "__main__":
    main()
@@ -1,18 +0,0 @@
-#!/usr/bin/env python3
-# Copyright 2017 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import gtest_parallel
-import sys
-
-sys.exit(gtest_parallel.main())
@@ -1,959 +0,0 @@
-#  Copyright (c) Meta Platforms, Inc. and affiliates.
-#  This source code is licensed under both the GPLv2 (found in the COPYING file in the root directory)
-#  and the Apache 2.0 License (found in the LICENSE.Apache file in the root directory).
-
-# Copyright 2013 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import errno
-from functools import total_ordering
-import gzip
-import io
-import json
-import multiprocessing
-import optparse
-import os
-import re
-import shutil
-import signal
-import subprocess
-import sys
-import tempfile
-import threading
-import time
-
-if sys.version_info.major >= 3:
-  long = int
-  import _pickle as cPickle
-  import _thread as thread
-else:
-  import cPickle
-  import thread
-
-from pickle import HIGHEST_PROTOCOL as PICKLE_HIGHEST_PROTOCOL
-
-if sys.platform == 'win32':
-  import msvcrt
-else:
-  import fcntl
-
-
-# An object that catches SIGINT sent to the Python process and notices
-# if processes passed to wait() die by SIGINT (we need to look for
-# both of those cases, because pressing Ctrl+C can result in either
-# the main process or one of the subprocesses getting the signal).
-#
-# Before a SIGINT is seen, wait(p) will simply call p.wait() and
-# return the result. Once a SIGINT has been seen (in the main process
-# or a subprocess, including the one the current call is waiting for),
-# wait(p) will call p.terminate() and raise ProcessWasInterrupted.
-class SigintHandler(object):
-  class ProcessWasInterrupted(Exception):
-    pass
-
-  sigint_returncodes = {
-      -signal.SIGINT,  # Unix
-      -1073741510,  # Windows
-  }
-
-  def __init__(self):
-    self.__lock = threading.Lock()
-    self.__processes = set()
-    self.__got_sigint = False
-    signal.signal(signal.SIGINT, lambda signal_num, frame: self.interrupt())
-
-  def __on_sigint(self):
-    self.__got_sigint = True
-    while self.__processes:
-      try:
-        self.__processes.pop().terminate()
-      except OSError:
-        pass
-
-  def interrupt(self):
-    with self.__lock:
-      self.__on_sigint()
-
-  def got_sigint(self):
-    with self.__lock:
-      return self.__got_sigint
-
-  def wait(self, p, timeout_per_test):
-    with self.__lock:
-      if self.__got_sigint:
-        p.terminate()
-      self.__processes.add(p)
-    try:
-      code = p.wait(timeout_per_test)
-    except subprocess.TimeoutExpired :
-      p.terminate()
-      self.__processes.remove(p)
-      code = -errno.ETIME
-    with self.__lock:
-      self.__processes.discard(p)
-      if code in self.sigint_returncodes:
-        self.__on_sigint()
-      if self.__got_sigint:
-        raise self.ProcessWasInterrupted
-    return code
-
-
-sigint_handler = SigintHandler()
-
-
-# Return the width of the terminal, or None if it couldn't be
-# determined (e.g. because we're not being run interactively).
-def term_width(out):
-  if not out.isatty():
-    return None
-  try:
-    p = subprocess.Popen(["stty", "size"],
-                         stdout=subprocess.PIPE,
-                         stderr=subprocess.PIPE)
-    (out, err) = p.communicate()
-    if p.returncode != 0 or err:
-      return None
-    return int(out.split()[1])
-  except (IndexError, OSError, ValueError):
-    return None
-
-
-# Output transient and permanent lines of text. If several transient
-# lines are written in sequence, the new will overwrite the old. We
-# use this to ensure that lots of unimportant info (tests passing)
-# won't drown out important info (tests failing).
-class Outputter(object):
-  def __init__(self, out_file):
-    self.__out_file = out_file
-    self.__previous_line_was_transient = False
-    self.__width = term_width(out_file)  # Line width, or None if not a tty.
-
-  def transient_line(self, msg):
-    if self.__width is None:
-      self.__out_file.write(msg + "\n")
-      self.__out_file.flush()
-    else:
-      self.__out_file.write("\r" + msg[:self.__width].ljust(self.__width))
-      self.__previous_line_was_transient = True
-
-  def flush_transient_output(self):
-    if self.__previous_line_was_transient:
-      self.__out_file.write("\n")
-      self.__previous_line_was_transient = False
-
-  def permanent_line(self, msg):
-    self.flush_transient_output()
-    self.__out_file.write(msg + "\n")
-    if self.__width is None:
-      self.__out_file.flush()
-
-
-def get_save_file_path():
-  """Return path to file for saving transient data."""
-  if sys.platform == 'win32':
-    default_cache_path = os.path.join(os.path.expanduser('~'), 'AppData',
-                                      'Local')
-    cache_path = os.environ.get('LOCALAPPDATA', default_cache_path)
-  else:
-    # We don't use xdg module since it's not a standard.
-    default_cache_path = os.path.join(os.path.expanduser('~'), '.cache')
-    cache_path = os.environ.get('XDG_CACHE_HOME', default_cache_path)
-
-  if os.path.isdir(cache_path):
-    return os.path.join(cache_path, 'gtest-parallel')
-  else:
-    sys.stderr.write('Directory {} does not exist'.format(cache_path))
-    return os.path.join(os.path.expanduser('~'), '.gtest-parallel-times')
-
-
-@total_ordering
-class Task(object):
-  """Stores information about a task (single execution of a test).
-
-  This class stores information about the test to be executed (gtest binary and
-  test name), and its result (log file, exit code and runtime).
-  Each task is uniquely identified by the gtest binary, the test name and an
-  execution number that increases each time the test is executed.
-  Additionaly we store the last execution time, so that next time the test is
-  executed, the slowest tests are run first.
-  """
-
-  def __init__(self, test_binary, test_name, test_command, execution_number,
-               last_execution_time, output_dir):
-    self.test_name = test_name
-    self.output_dir = output_dir
-    self.test_binary = test_binary
-    self.test_command = test_command
-    self.execution_number = execution_number
-    self.last_execution_time = last_execution_time
-
-    self.exit_code = None
-    self.runtime_ms = None
-
-    self.test_id = (test_binary, test_name)
-    self.task_id = (test_binary, test_name, self.execution_number)
-
-    self.log_file = Task._logname(self.output_dir, self.test_binary, test_name,
-                                  self.execution_number)
-
-  def __sorting_key(self):
-    # Unseen or failing tests (both missing execution time) take precedence over
-    # execution time. Tests are greater (seen as slower) when missing times so
-    # that they are executed first.
-    return (1 if self.last_execution_time is None else 0,
-            self.last_execution_time)
-
-  def __eq__(self, other):
-    return self.__sorting_key() == other.__sorting_key()
-
-  def __ne__(self, other):
-    return not (self == other)
-
-  def __lt__(self, other):
-    return self.__sorting_key() < other.__sorting_key()
-
-  @staticmethod
-  def _normalize(string):
-    return re.sub('[^A-Za-z0-9]', '_', string)
-
-  @staticmethod
-  def _logname(output_dir, test_binary, test_name, execution_number):
-    # Store logs to temporary files if there is no output_dir.
-    if output_dir is None:
-      (log_handle, log_name) = tempfile.mkstemp(prefix='gtest_parallel_',
-                                                suffix=".log")
-      os.close(log_handle)
-      return log_name
-
-    log_name = '%s-%s-%d.log' % (Task._normalize(os.path.basename(test_binary)),
-                                 Task._normalize(test_name), execution_number)
-
-    return os.path.join(output_dir, log_name)
-
-  def run(self, timeout_per_test):
-    begin = time.time()
-    with open(self.log_file, 'w') as log:
-      task = subprocess.Popen(self.test_command, stdout=log, stderr=log)
-      try:
-        self.exit_code = sigint_handler.wait(task, timeout_per_test)
-      except sigint_handler.ProcessWasInterrupted:
-        thread.exit()
-    self.runtime_ms = int(1000 * (time.time() - begin))
-    self.last_execution_time = None if self.exit_code else self.runtime_ms
-
-
-class TaskManager(object):
-  """Executes the tasks and stores the passed, failed and interrupted tasks.
-
-  When a task is run, this class keeps track if it passed, failed or was
-  interrupted. After a task finishes it calls the relevant functions of the
-  Logger, TestResults and TestTimes classes, and in case of failure, retries the
-  test as specified by the --retry_failed flag.
-  """
-
-  def __init__(self, times, logger, test_results, task_factory, times_to_retry,
-               initial_execution_number):
-    self.times = times
-    self.logger = logger
-    self.test_results = test_results
-    self.task_factory = task_factory
-    self.times_to_retry = times_to_retry
-    self.initial_execution_number = initial_execution_number
-
-    self.global_exit_code = 0
-
-    self.passed = []
-    self.failed = []
-    self.started = {}
-    self.timed_out = []
-    self.execution_number = {}
-
-    self.lock = threading.Lock()
-
-  def __get_next_execution_number(self, test_id):
-    with self.lock:
-      next_execution_number = self.execution_number.setdefault(
-          test_id, self.initial_execution_number)
-      self.execution_number[test_id] += 1
-    return next_execution_number
-
-  def __register_start(self, task):
-    with self.lock:
-      self.started[task.task_id] = task
-
-  def register_exit(self, task):
-    self.logger.log_exit(task)
-    self.times.record_test_time(task.test_binary, task.test_name,
-                                task.last_execution_time)
-    if self.test_results:
-      self.test_results.log(task.test_name, task.runtime_ms / 1000.0,
-                            task.exit_code)
-
-    with self.lock:
-      self.started.pop(task.task_id)
-      if task.exit_code == 0:
-        self.passed.append(task)
-      elif task.exit_code == -errno.ETIME:
-        self.timed_out.append(task)
-      else:
-        self.failed.append(task)
-
-  def run_task(self, task, timeout_per_test):
-    for try_number in range(self.times_to_retry + 1):
-      self.__register_start(task)
-      task.run(timeout_per_test)
-      self.register_exit(task)
-
-      if task.exit_code == 0:
-        break
-
-      if try_number < self.times_to_retry:
-        execution_number = self.__get_next_execution_number(task.test_id)
-        # We need create a new Task instance. Each task represents a single test
-        # execution, with its own runtime, exit code and log file.
-        task = self.task_factory(task.test_binary, task.test_name,
-                                 task.test_command, execution_number,
-                                 task.last_execution_time, task.output_dir)
-
-    with self.lock:
-      if task.exit_code != 0:
-        self.global_exit_code = task.exit_code
-
-
-class FilterFormat(object):
-  def __init__(self, output_dir):
-    if sys.stdout.isatty():
-      # stdout needs to be unbuffered since the output is interactive.
-      if isinstance(sys.stdout, io.TextIOWrapper):
-        # workaround for https://bugs.python.org/issue17404
-        sys.stdout = io.TextIOWrapper(sys.stdout.detach(),
-                                      line_buffering=True,
-                                      write_through=True,
-                                      newline='\n')
-      else:
-        sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)
-
-    self.output_dir = output_dir
-
-    self.total_tasks = 0
-    self.finished_tasks = 0
-    self.out = Outputter(sys.stdout)
-    self.stdout_lock = threading.Lock()
-
-  def move_to(self, destination_dir, tasks):
-    if self.output_dir is None:
-      return
-
-    destination_dir = os.path.join(self.output_dir, destination_dir)
-    os.makedirs(destination_dir)
-    for task in tasks:
-      shutil.move(task.log_file, destination_dir)
-
-  def print_tests(self, message, tasks, print_try_number, print_test_command):
-    self.out.permanent_line("%s (%s/%s):" %
-                            (message, len(tasks), self.total_tasks))
-    for task in sorted(tasks):
-      runtime_ms = 'Interrupted'
-      if task.runtime_ms is not None:
-        runtime_ms = '%d ms' % task.runtime_ms
-      if print_test_command:
-        try:
-          cmd_str = " ".join(task.test_command)
-        except TypeError:
-          cmd_str = task.test_command
-        self.out.permanent_line(
-            "%11s: %s%s" %
-            (runtime_ms, cmd_str,
-            (" (try #%d)" % task.execution_number) if print_try_number else ""))
-      else:
-        self.out.permanent_line(
-            "%11s: %s %s%s" %
-            (runtime_ms, task.test_binary, task.test_name,
-            (" (try #%d)" % task.execution_number) if print_try_number else ""))
-
-  def log_exit(self, task):
-    with self.stdout_lock:
-      self.finished_tasks += 1
-      self.out.transient_line("[%d/%d] %s (%d ms)" %
-                              (self.finished_tasks, self.total_tasks,
-                               task.test_name, task.runtime_ms))
-      if task.exit_code != 0:
-        signal_name = None
-        if task.exit_code < 0:
-          try:
-            signal_name = signal.Signals(-task.exit_code).name
-          except ValueError:
-            pass
-
-        with open(task.log_file) as f:
-          for line in f.readlines():
-            self.out.permanent_line(line.rstrip())
-        if task.exit_code is None:
-          self.out.permanent_line("[%d/%d] %s aborted after %d ms" %
-                                  (self.finished_tasks, self.total_tasks,
-                                   task.test_name, task.runtime_ms))
-        elif task.exit_code == -errno.ETIME:
-          self.out.permanent_line(
-            "\033[31m[  TIMEOUT ]\033[0m %s timed out after %d s"
-            % (task.test_name, task.runtime_ms/1000))
-        elif signal_name is not None:
-          self.out.permanent_line(
-              "[%d/%d] %s killed by signal %s (%d ms)" %
-              (self.finished_tasks, self.total_tasks, task.test_name,
-               signal_name, task.runtime_ms))
-        else:
-          self.out.permanent_line(
-              "[%d/%d] %s returned with exit code %d (%d ms)" %
-              (self.finished_tasks, self.total_tasks, task.test_name,
-               task.exit_code, task.runtime_ms))
-
-    if self.output_dir is None:
-      # Try to remove the file 100 times (sleeping for 0.1 second in between).
-      # This is a workaround for a process handle seemingly holding on to the
-      # file for too long inside os.subprocess. This workaround is in place
-      # until we figure out a minimal repro to report upstream (or a better
-      # suspect) to prevent os.remove exceptions.
-      num_tries = 100
-      for i in range(num_tries):
-        try:
-          os.remove(task.log_file)
-        except OSError as e:
-          if e.errno is not errno.ENOENT:
-            if i is num_tries - 1:
-              self.out.permanent_line('Could not remove temporary log file: ' +
-                                      str(e))
-            else:
-              time.sleep(0.1)
-            continue
-        break
-
-  def log_tasks(self, total_tasks):
-    self.total_tasks += total_tasks
-    self.out.transient_line("[0/%d] Running tests..." % self.total_tasks)
-
-  def summarize(self, passed_tasks, failed_tasks, interrupted_tasks):
-    stats = {}
-
-    def add_stats(stats, task, idx):
-      task_key = (task.test_binary, task.test_name)
-      if not task_key in stats:
-        # (passed, failed, interrupted) task_key is added as tie breaker to get
-        # alphabetic sorting on equally-stable tests
-        stats[task_key] = [0, 0, 0, task_key]
-      stats[task_key][idx] += 1
-
-    for task in passed_tasks:
-      add_stats(stats, task, 0)
-    for task in failed_tasks:
-      add_stats(stats, task, 1)
-    for task in interrupted_tasks:
-      add_stats(stats, task, 2)
-
-    self.out.permanent_line("SUMMARY:")
-    for task_key in sorted(stats, key=stats.__getitem__):
-      (num_passed, num_failed, num_interrupted, _) = stats[task_key]
-      (test_binary, task_name) = task_key
-      total_runs = num_passed + num_failed + num_interrupted
-      if num_passed == total_runs:
-        continue
-      self.out.permanent_line("  %s %s passed %d / %d times%s." %
-                              (test_binary, task_name, num_passed, total_runs,
-                               "" if num_interrupted == 0 else
-                               (" (%d interrupted)" % num_interrupted)))
-
-  def flush(self):
-    self.out.flush_transient_output()
-
-
-class CollectTestResults(object):
-  def __init__(self, json_dump_filepath):
-    self.test_results_lock = threading.Lock()
-    self.json_dump_file = open(json_dump_filepath, 'w')
-    self.test_results = {
-        "interrupted": False,
-        "path_delimiter": ".",
-        # Third version of the file format. See the link in the flag description
-        # for details.
-        "version": 3,
-        "seconds_since_epoch": int(time.time()),
-        "num_failures_by_type": {
-            "PASS": 0,
-            "FAIL": 0,
-            "TIMEOUT": 0,
-        },
-        "tests": {},
-    }
-
-  def log(self, test, runtime_seconds, exit_code):
-    if exit_code is None:
-      actual_result = "TIMEOUT"
-    elif exit_code == 0:
-      actual_result = "PASS"
-    else:
-      actual_result = "FAIL"
-    with self.test_results_lock:
-      self.test_results['num_failures_by_type'][actual_result] += 1
-      results = self.test_results['tests']
-      for name in test.split('.'):
-        results = results.setdefault(name, {})
-
-      if results:
-        results['actual'] += ' ' + actual_result
-        results['times'].append(runtime_seconds)
-      else:  # This is the first invocation of the test
-        results['actual'] = actual_result
-        results['times'] = [runtime_seconds]
-        results['time'] = runtime_seconds
-        results['expected'] = 'PASS'
-
-  def dump_to_file_and_close(self):
-    json.dump(self.test_results, self.json_dump_file)
-    self.json_dump_file.close()
-
-
-# Record of test runtimes. Has built-in locking.
-class TestTimes(object):
-  class LockedFile(object):
-    def __init__(self, filename, mode):
-      self._filename = filename
-      self._mode = mode
-      self._fo = None
-
-    def __enter__(self):
-      self._fo = open(self._filename, self._mode)
-
-      # Regardless of opening mode we always seek to the beginning of file.
-      # This simplifies code working with LockedFile and also ensures that
-      # we lock (and unlock below) always the same region in file on win32.
-      self._fo.seek(0)
-
-      try:
-        if sys.platform == 'win32':
-          # We are locking here fixed location in file to use it as
-          # an exclusive lock on entire file.
-          msvcrt.locking(self._fo.fileno(), msvcrt.LK_LOCK, 1)
-        else:
-          fcntl.flock(self._fo.fileno(), fcntl.LOCK_EX)
-      except IOError:
-        self._fo.close()
-        raise
-
-      return self._fo
-
-    def __exit__(self, exc_type, exc_value, traceback):
-      # Flush any buffered data to disk. This is needed to prevent race
-      # condition which happens from the moment of releasing file lock
-      # till closing the file.
-      self._fo.flush()
-
-      try:
-        if sys.platform == 'win32':
-          self._fo.seek(0)
-          msvcrt.locking(self._fo.fileno(), msvcrt.LK_UNLCK, 1)
-        else:
-          fcntl.flock(self._fo.fileno(), fcntl.LOCK_UN)
-      finally:
-        self._fo.close()
-
-      return exc_value is None
-
-  def __init__(self, save_file):
-    "Create new object seeded with saved test times from the given file."
-    self.__times = {}  # (test binary, test name) -> runtime in ms
-
-    # Protects calls to record_test_time(); other calls are not
-    # expected to be made concurrently.
-    self.__lock = threading.Lock()
-
-    try:
-      with TestTimes.LockedFile(save_file, 'rb') as fd:
-        times = TestTimes.__read_test_times_file(fd)
-    except IOError:
-      # We couldn't obtain the lock.
-      return
-
-    # Discard saved times if the format isn't right.
-    if type(times) is not dict:
-      return
-    for ((test_binary, test_name), runtime) in times.items():
-      if (type(test_binary) is not str or type(test_name) is not str
-          or type(runtime) not in {int, long, type(None)}):
-        return
-
-    self.__times = times
-
-  def get_test_time(self, binary, testname):
-    """Return the last duration for the given test as an integer number of
-    milliseconds, or None if the test failed or if there's no record for it."""
-    return self.__times.get((binary, testname), None)
-
-  def record_test_time(self, binary, testname, runtime_ms):
-    """Record that the given test ran in the specified number of
-    milliseconds. If the test failed, runtime_ms should be None."""
-    with self.__lock:
-      self.__times[(binary, testname)] = runtime_ms
-
-  def write_to_file(self, save_file):
-    "Write all the times to file."
-    try:
-      with TestTimes.LockedFile(save_file, 'a+b') as fd:
-        times = TestTimes.__read_test_times_file(fd)
-
-        if times is None:
-          times = self.__times
-        else:
-          times.update(self.__times)
-
-        # We erase data from file while still holding a lock to it. This
-        # way reading old test times and appending new ones are atomic
-        # for external viewer.
-        fd.seek(0)
-        fd.truncate()
-        with gzip.GzipFile(fileobj=fd, mode='wb') as gzf:
-          cPickle.dump(times, gzf, PICKLE_HIGHEST_PROTOCOL)
-    except IOError:
-      pass  # ignore errors---saving the times isn't that important
-
-  @staticmethod
-  def __read_test_times_file(fd):
-    try:
-      with gzip.GzipFile(fileobj=fd, mode='rb') as gzf:
-        times = cPickle.load(gzf)
-    except Exception:
-      # File doesn't exist, isn't readable, is malformed---whatever.
-      # Just ignore it.
-      return None
-    else:
-      return times
-
-
-def find_tests(binaries, additional_args, options, times):
-  test_count = 0
-  tasks = []
-  for test_binary in binaries:
-    command = [test_binary] + additional_args
-    if options.gtest_also_run_disabled_tests:
-      command += ['--gtest_also_run_disabled_tests']
-
-    list_command = command + ['--gtest_list_tests']
-    if options.gtest_filter != '':
-      list_command += ['--gtest_filter=' + options.gtest_filter]
-
-    try:
-      test_list = subprocess.check_output(list_command,
-                                          stderr=subprocess.STDOUT)
-    except subprocess.CalledProcessError as e:
-      sys.exit("%s: %s\n%s" % (test_binary, str(e), e.output))
-
-    try:
-      test_list = test_list.split('\n')
-    except TypeError:
-      # subprocess.check_output() returns bytes in python3
-      test_list = test_list.decode(sys.stdout.encoding).split('\n')
-
-    command += ['--gtest_color=' + options.gtest_color]
-
-    test_group = ''
-    for line in test_list:
-      if not line.strip():
-        continue
-      if line[0] != " ":
-        # Remove comments for typed tests and strip whitespace.
-        test_group = line.split('#')[0].strip()
-        continue
-      # Remove comments for parameterized tests and strip whitespace.
-      line = line.split('#')[0].strip()
-      if not line:
-        continue
-
-      test_name = test_group + line
-      if not options.gtest_also_run_disabled_tests and 'DISABLED_' in test_name:
-        continue
-
-      # Skip PRE_ tests which are used by Chromium.
-      if '.PRE_' in test_name:
-        continue
-
-      last_execution_time = times.get_test_time(test_binary, test_name)
-      if options.failed and last_execution_time is not None:
-        continue
-
-      test_command = command + ['--gtest_filter=' + test_name]
-      if (test_count - options.shard_index) % options.shard_count == 0:
-        for execution_number in range(options.repeat):
-          tasks.append(
-              Task(test_binary, test_name, test_command, execution_number + 1,
-                   last_execution_time, options.output_dir))
-
-      test_count += 1
-
-  # Sort the tasks to run the slowest tests first, so that faster ones can be
-  # finished in parallel.
-  return sorted(tasks, reverse=True)
-
-
-def execute_tasks(tasks, pool_size, task_manager, timeout_seconds,
-                  timeout_per_test, serialize_test_cases):
-  class WorkerFn(object):
-    def __init__(self, tasks, running_groups, timeout_per_test):
-      self.tasks = tasks
-      self.running_groups = running_groups
-      self.timeout_per_test = timeout_per_test
-      self.task_lock = threading.Lock()
-
-    def __call__(self):
-      while True:
-        with self.task_lock:
-          for task_id in range(len(self.tasks)):
-            task = self.tasks[task_id]
-
-            if self.running_groups is not None:
-              test_group = task.test_name.split('.')[0]
-              if test_group in self.running_groups:
-                # Try to find other non-running test group.
-                continue
-              else:
-                self.running_groups.add(test_group)
-
-            del self.tasks[task_id]
-            break
-          else:
-            # Either there is no tasks left or number or remaining test
-            # cases (groups) is less than number or running threads.
-            return
-
-        task_manager.run_task(task, self.timeout_per_test)
-
-        if self.running_groups is not None:
-          with self.task_lock:
-            self.running_groups.remove(test_group)
-
-  def start_daemon(func):
-    t = threading.Thread(target=func)
-    t.daemon = True
-    t.start()
-    return t
-
-  timeout = None
-  try:
-    if timeout_seconds:
-      timeout = threading.Timer(timeout_seconds, sigint_handler.interrupt)
-      timeout.start()
-    running_groups = set() if serialize_test_cases else None
-    worker_fn = WorkerFn(tasks, running_groups, timeout_per_test)
-    workers = [start_daemon(worker_fn) for _ in range(pool_size)]
-    for worker in workers:
-      worker.join()
-  finally:
-    if timeout:
-      timeout.cancel()
-      for task in list(task_manager.started.values()):
-        task.runtime_ms = timeout_seconds * 1000
-        task_manager.register_exit(task)
-
-
-def default_options_parser():
-  parser = optparse.OptionParser(
-      usage='usage: %prog [options] binary [binary ...] -- [additional args]')
-
-  parser.add_option('-d',
-                    '--output_dir',
-                    type='string',
-                    default=None,
-                    help='Output directory for test logs. Logs will be '
-                    'available under gtest-parallel-logs/, so '
-                    '--output_dir=/tmp will results in all logs being '
-                    'available under /tmp/gtest-parallel-logs/.')
-  parser.add_option('-r',
-                    '--repeat',
-                    type='int',
-                    default=1,
-                    help='Number of times to execute all the tests.')
-  parser.add_option('--retry_failed',
-                    type='int',
-                    default=0,
-                    help='Number of times to repeat failed tests.')
-  parser.add_option('--failed',
-                    action='store_true',
-                    default=False,
-                    help='run only failed and new tests')
-  parser.add_option('-w',
-                    '--workers',
-                    type='int',
-                    default=multiprocessing.cpu_count(),
-                    help='number of workers to spawn')
-  parser.add_option('--gtest_color',
-                    type='string',
-                    default='yes',
-                    help='color output')
-  parser.add_option('--gtest_filter',
-                    type='string',
-                    default='',
-                    help='test filter')
-  parser.add_option('--gtest_also_run_disabled_tests',
-                    action='store_true',
-                    default=False,
-                    help='run disabled tests too')
-  parser.add_option(
-      '--print_test_times',
-      action='store_true',
-      default=False,
-      help='list the run time of each test at the end of execution')
-  parser.add_option(
-      '--print_test_command',
-      action='store_true',
-      default=False,
-      help='Print full test command instead of name')
-  parser.add_option('--shard_count',
-                    type='int',
-                    default=1,
-                    help='total number of shards (for sharding test execution '
-                    'between multiple machines)')
-  parser.add_option('--shard_index',
-                    type='int',
-                    default=0,
-                    help='zero-indexed number identifying this shard (for '
-                    'sharding test execution between multiple machines)')
-  parser.add_option(
-      '--dump_json_test_results',
-      type='string',
-      default=None,
-      help='Saves the results of the tests as a JSON machine-'
-      'readable file. The format of the file is specified at '
-      'https://www.chromium.org/developers/the-json-test-results-format')
-  parser.add_option('--timeout',
-                    type='int',
-                    default=None,
-                    help='Interrupt all remaining processes after the given '
-                    'time (in seconds).')
-  parser.add_option('--timeout_per_test',
-                    type='int',
-                    default=None,
-                    help='Interrupt single processes after the given '
-                    'time (in seconds).')
-  parser.add_option('--serialize_test_cases',
-                    action='store_true',
-                    default=False,
-                    help='Do not run tests from the same test '
-                    'case in parallel.')
-  return parser
-
-
-def main():
-  # Remove additional arguments (anything after --).
-  additional_args = []
-
-  for i in range(len(sys.argv)):
-    if sys.argv[i] == '--':
-      additional_args = sys.argv[i + 1:]
-      sys.argv = sys.argv[:i]
-      break
-
-  parser = default_options_parser()
-  (options, binaries) = parser.parse_args()
-
-  if (options.output_dir is not None and not os.path.isdir(options.output_dir)):
-    parser.error('--output_dir value must be an existing directory, '
-                 'current value is "%s"' % options.output_dir)
-
-  # Append gtest-parallel-logs to log output, this is to avoid deleting user
-  # data if an user passes a directory where files are already present. If a
-  # user specifies --output_dir=Docs/, we'll create Docs/gtest-parallel-logs
-  # and clean that directory out on startup, instead of nuking Docs/.
-  if options.output_dir:
-    options.output_dir = os.path.join(options.output_dir, 'gtest-parallel-logs')
-
-  if binaries == []:
-    parser.print_usage()
-    sys.exit(1)
-
-  if options.shard_count < 1:
-    parser.error("Invalid number of shards: %d. Must be at least 1." %
-                 options.shard_count)
-  if not (0 <= options.shard_index < options.shard_count):
-    parser.error("Invalid shard index: %d. Must be between 0 and %d "
-                 "(less than the number of shards)." %
-                 (options.shard_index, options.shard_count - 1))
-
-  # Check that all test binaries have an unique basename. That way we can ensure
-  # the logs are saved to unique files even when two different binaries have
-  # common tests.
-  unique_binaries = set(os.path.basename(binary) for binary in binaries)
-  assert len(unique_binaries) == len(binaries), (
-      "All test binaries must have an unique basename.")
-
-  if options.output_dir:
-    # Remove files from old test runs.
-    if os.path.isdir(options.output_dir):
-      shutil.rmtree(options.output_dir)
-    # Create directory for test log output.
-    try:
-      os.makedirs(options.output_dir)
-    except OSError as e:
-      # Ignore errors if this directory already exists.
-      if e.errno != errno.EEXIST or not os.path.isdir(options.output_dir):
-        raise e
-
-  test_results = None
-  if options.dump_json_test_results is not None:
-    test_results = CollectTestResults(options.dump_json_test_results)
-
-  save_file = get_save_file_path()
-
-  times = TestTimes(save_file)
-  logger = FilterFormat(options.output_dir)
-
-  task_manager = TaskManager(times, logger, test_results, Task,
-                             options.retry_failed, options.repeat + 1)
-
-  tasks = find_tests(binaries, additional_args, options, times)
-  logger.log_tasks(len(tasks))
-  execute_tasks(tasks, options.workers, task_manager, options.timeout,
-                options.timeout_per_test, options.serialize_test_cases)
-
-  print_try_number = options.retry_failed > 0 or options.repeat > 1
-  if task_manager.passed:
-    logger.move_to('passed', task_manager.passed)
-    if options.print_test_times:
-      logger.print_tests('PASSED TESTS', task_manager.passed, print_try_number, options.print_test_command)
-
-  if task_manager.failed:
-    logger.print_tests('FAILED TESTS', task_manager.failed, print_try_number, options.print_test_command)
-    logger.move_to('failed', task_manager.failed)
-
-  if task_manager.timed_out:
-    logger.print_tests('TIMED OUT TESTS', task_manager.timed_out, print_try_number, options.print_test_command)
-    logger.move_to('timed_out', task_manager.timed_out)
-
-  if task_manager.started:
-    logger.print_tests('INTERRUPTED TESTS', task_manager.started.values(),
-                       print_try_number, options.print_test_command)
-    logger.move_to('interrupted', task_manager.started.values())
-
-  if options.repeat > 1 and (task_manager.failed or task_manager.started):
-    logger.summarize(task_manager.passed, task_manager.failed,
-                     task_manager.started.values())
-
-  logger.flush()
-  times.write_to_file(save_file)
-  if test_results:
-    test_results.dump_to_file_and_close()
-
-  if sigint_handler.got_sigint():
-    return -signal.SIGINT
-
-  return task_manager.global_exit_code
-
-
-if __name__ == "__main__":
-  sys.exit(main())
@@ -1,67 +0,0 @@
-#!/usr/bin/env bash
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# This source code is licensed under both the GPLv2 (found in the
-# COPYING file in the root directory) and Apache 2.0 License
-# (found in the LICENSE.Apache file in the root directory).
-#
-# Build RocksDB unit test binaries and run them under gtest-parallel,
-# which shards the test cases across CPUs for faster execution.
-#
-# Hardened version of a simple `make <bin> && gtest-parallel ./<bin>` helper:
-#  * AUTO_CLEAN=1 so the Makefile automatically runs a clean when the build
-#    parameters (DEBUG_LEVEL, sanitizers, ASSERT_STATUS_CHECKED, RTTI, etc.)
-#    have changed since the last build, preventing stale/mixed object files.
-#  * Parallel build with -j<NCORES>, computed the same way the Makefile does.
-#  * Uses the gtest-parallel checked in alongside this script (build_tools/),
-#    so it works regardless of PATH.
-#  * `set -euo pipefail` so any failure stops the script.
-#
-# Run from the repository root.
-#
-# Accepts one or more test binaries (gtest-parallel pools all their test cases
-# into one shared worker queue). The leading non-option arguments are treated as
-# binaries; everything from the first option onward is forwarded to
-# gtest-parallel / the test binaries.
-#
-# Example usage:
-#   build_tools/rocksptest.sh db_test
-#   build_tools/rocksptest.sh db_test -r1000 --gtest_filter=*MixedSlowdown*
-#   build_tools/rocksptest.sh db_test env_test db_basic_test
-#   build_tools/rocksptest.sh db_test env_test --gtest_filter=*Foo*
-
-set -euo pipefail
-
-if [ "$#" -lt 1 ]; then
-  echo "usage: $0 <test_binary> [more_test_binaries...] [gtest-parallel/test args...]" >&2
-  echo "example: $0 db_test env_test -r1000 --gtest_filter=*MixedSlowdown*" >&2
-  exit 1
-fi
-
-# First argument must be a test binary, not an option (catches a forgotten name).
-if [ "${1#-}" != "$1" ]; then
-  echo "$0: first argument must be a test binary name, not an option ('$1')" >&2
-  exit 1
-fi
-
-# Collect the leading non-option arguments as test binaries; everything from the
-# first option onward is forwarded to gtest-parallel / the test binaries.
-BINS=()
-while [ "$#" -gt 0 ] && [ "${1#-}" = "$1" ]; do
-  BINS+=("$1")
-  shift
-done
-
-# Paths as gtest-parallel expects them (relative to the current directory).
-BIN_PATHS=()
-for b in "${BINS[@]}"; do
-  BIN_PATHS+=("./$b")
-done
-
-# Directory of this script, so we use the gtest-parallel checked in next to it.
-SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
-
-# Compute parallelism the same way the Makefile computes NCORES.
-NCORES=$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 4)
-
-make AUTO_CLEAN=1 -j"$NCORES" "${BINS[@]}"
-"$SCRIPT_DIR/gtest-parallel" "${BIN_PATHS[@]}" "$@"
@@ -1,76 +0,0 @@
-#!/usr/bin/env bash
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# This source code is licensed under both the GPLv2 (found in the
-# COPYING file in the root directory) and Apache 2.0 License
-# (found in the LICENSE.Apache file in the root directory).
-#
-# Build a single RocksDB unit test binary and run it directly (serially).
-# Only recommended with --gtest_filter=... because of speed. See also
-# build_tools/rocksptest.sh
-#
-# Hardened version of a simple `make <bin> && ./<bin>` helper:
-#  * AUTO_CLEAN=1 so the Makefile automatically runs a clean when the build
-#    parameters (DEBUG_LEVEL, sanitizers, ASSERT_STATUS_CHECKED, RTTI, etc.)
-#    have changed since the last build, preventing stale/mixed object files.
-#  * Parallel build with -j<NCORES>, computed the same way the Makefile does.
-#  * `set -euo pipefail` so any failure stops the script.
-#
-# Run from the repository root.
-#
-# Example usage:
-#   build_tools/rockstest.sh db_test --gtest_filter=*MixedSlowdown*
-#   build_tools/rockstest.sh env_test # Slow to run many tests serially
-#
-# Install mode:
-#   build_tools/rockstest.sh install
-#     Creates ~/bin/rockstest and ~/bin/rocksptest shims that defer to
-#     build_tools/rockstest.sh / rocksptest.sh in whatever directory you run
-#     them from, so you can just type `rockstest db_test` from any rocksdb
-#     source root.
-
-set -euo pipefail
-
-# Install mode: write thin ~/bin shims that defer to the build_tools scripts in
-# the current directory.
-if [ "${1:-}" = "install" ]; then
-  mkdir -p "$HOME/bin"
-  for name in rockstest rocksptest; do
-    dest="$HOME/bin/$name"
-    cat > "$dest" <<EOF
-#!/usr/bin/env bash
-# Auto-generated by 'build_tools/rockstest.sh install'. Defers to
-# build_tools/$name.sh in the current rocksdb source root.
-if [ -x build_tools/$name.sh ]; then
-  exec build_tools/$name.sh "\$@"
-else
-  echo "build_tools/$name.sh not found (Not in a rocksdb source root directory?)" >&2
-  exit 1
-fi
-EOF
-    chmod +x "$dest"
-    echo "Installed $dest"
-  done
-  exit 0
-fi
-
-if [ "$#" -lt 1 ]; then
-  echo "usage: $0 <test_binary> [test args...]" >&2
-  echo "       $0 install   # create ~/bin/rockstest and ~/bin/rocksptest shims" >&2
-  echo "example: $0 db_test --gtest_filter=*MixedSlowdown*" >&2
-  exit 1
-fi
-
-# First argument must be a test binary, not an option (catches a forgotten name).
-if [ "${1#-}" != "$1" ]; then
-  echo "$0: first argument must be a test binary name, not an option ('$1')" >&2
-  exit 1
-fi
-
-BIN=$1
-shift
-
-# Compute parallelism the same way the Makefile computes NCORES.
-NCORES=$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 4)
-
-make AUTO_CLEAN=1 -j"$NCORES" "$BIN"
-./"$BIN" "$@"
@@ -32,7 +32,7 @@ function get_lib_base()
  local lib_platform=$3

  local result="$TP2_LATEST/$lib_name/"
-
+  
  # Lib Version
  if [ -z "$lib_version" ] || [ "$lib_version" = "LATEST" ]; then
    # version is not provided, use latest
@@ -40,7 +40,7 @@ function get_lib_base()
  else
    result="$result/$lib_version/"
  fi
-
+  
  # Lib Platform
  if [ -z "$lib_platform" ]; then
    # platform is not provided, use latest gcc
@@ -49,17 +49,17 @@ function get_lib_base()
    echo $lib_platform
    result="$result/$lib_platform/"
  fi
-
+  
  result=`ls -1d $result/*/ | head -n1`

  echo Finding link $result
-
+  
  # lib_name => LIB_NAME_BASE
  local __res_var=${lib_name^^}"_BASE"
  __res_var=`echo $__res_var | tr - _`
  # LIB_NAME_BASE=$result
  eval $__res_var=`readlink -f $result`
-
+  
  log_variable $__res_var
 }

@@ -75,33 +75,17 @@ touch "$OUTPUT"
 echo "Writing dependencies to $OUTPUT"

 # Compilers locations
-# GCC is pinned to 11.x because the only newer GCC in third-party2 (13.x) is
-# built for centos9/glibc>=2.35 -- its libgcc_s.so.1 has a hard reference
-# to _dl_find_object@GLIBC_2.35, but platform010 ships glibc 2.34. Bumping
-# GCC requires a platform with glibc >= 2.35.
-GCC_BASE=`readlink -f $TP2_LATEST/gcc/11.x/centos9-native/*/`
-# Clang is pinned to the latest tested major (21). Bump deliberately.
-CLANG_BASE=`readlink -f $TP2_LATEST/llvm-fb/21/platform010/*/`
+GCC_BASE=`readlink -f $TP2_LATEST/gcc/11.x/centos8-native/*/`
+CLANG_BASE=`readlink -f $TP2_LATEST/llvm-fb/15/platform010/*/`

 log_header
 log_variable GCC_BASE
 log_variable CLANG_BASE

 # Libraries locations
-# libgcc is pinned to 11.x to match the GCC 11 compiler above (libstdc++/
-# libgcc runtime, ABI, and C++ headers). Bump in lockstep with GCC_BASE.
 get_lib_base libgcc     11.x    platform010
-# glibc 2.34 is the platform010 ABI baseline (ld.so + libc); it is also the
-# only version available in third-party2, and defines the platform -- do
-# not bump independently.
 get_lib_base glibc      2.34    platform010
 get_lib_base snappy     LATEST  platform010
-# zlib is pinned to 1.2.8: it is the latest version with an x86_64
-# platform010 build (1.2.13 / 1.3.1 are centos9 / aarch64 only). At time of
-# writing, LATEST here doesn't work: get_lib_base picks the newest version
-# dir first and only then appends the platform, with no fallback -- so
-# LATEST would resolve to 1.3.1, find no platform010 build, and emit an
-# empty ZLIB_BASE.
 get_lib_base zlib       1.2.8   platform010
 get_lib_base bzip2      LATEST  platform010
 get_lib_base lz4        LATEST  platform010
@@ -110,11 +94,12 @@ get_lib_base gflags     LATEST  platform010
 get_lib_base jemalloc   LATEST  platform010
 get_lib_base numa       LATEST  platform010
 get_lib_base libunwind  LATEST  platform010
+get_lib_base tbb        2018_U5 platform010
 get_lib_base liburing   LATEST  platform010
 get_lib_base benchmark  LATEST  platform010

 get_lib_base kernel-headers fb platform010
-get_lib_base binutils   LATEST centos9-native
+get_lib_base binutils   LATEST centos8-native
 get_lib_base valgrind   LATEST platform010

 git diff $OUTPUT
@@ -1,39 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/generate_c_api.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Source: tools/c_api_gen/spec.json
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/generate_c_api.py
-//     --spec tools/c_api_gen/spec.json --section 'BlockBasedOptions simple'
-//     --header-out
-//     c_api_gen/c_generated_block_based_options_subset.h.inc
-//     --source-out
-//     c_api_gen/c_generated_block_based_options_subset.cc.inc
-
-/* BlockBasedOptions simple */
-
-void rocksdb_block_based_options_set_data_block_hash_ratio(
-    rocksdb_block_based_table_options_t* options, double v) {
-  options->rep.data_block_hash_table_util_ratio = v;
-}
-
-void rocksdb_block_based_options_set_top_level_index_pinning_tier(
-    rocksdb_block_based_table_options_t* options, int v) {
-  options->rep.metadata_cache_options.top_level_index_pinning =
-      static_cast<ROCKSDB_NAMESPACE::PinningTier>(v);
-}
-
-void rocksdb_block_based_options_set_partition_pinning_tier(
-    rocksdb_block_based_table_options_t* options, int v) {
-  options->rep.metadata_cache_options.partition_pinning =
-      static_cast<ROCKSDB_NAMESPACE::PinningTier>(v);
-}
-
-void rocksdb_block_based_options_set_unpartitioned_pinning_tier(
-    rocksdb_block_based_table_options_t* options, int v) {
-  options->rep.metadata_cache_options.unpartitioned_pinning =
-      static_cast<ROCKSDB_NAMESPACE::PinningTier>(v);
-}
@@ -1,32 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/generate_c_api.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Source: tools/c_api_gen/spec.json
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/generate_c_api.py
-//     --spec tools/c_api_gen/spec.json --section 'BlockBasedOptions simple'
-//     --header-out
-//     c_api_gen/c_generated_block_based_options_subset.h.inc
-//     --source-out
-//     c_api_gen/c_generated_block_based_options_subset.cc.inc
-
-/* BlockBasedOptions simple */
-
-extern ROCKSDB_LIBRARY_API void
-rocksdb_block_based_options_set_data_block_hash_ratio(
-    rocksdb_block_based_table_options_t* options, double v);
-
-extern ROCKSDB_LIBRARY_API void
-rocksdb_block_based_options_set_top_level_index_pinning_tier(
-    rocksdb_block_based_table_options_t* options, int v);
-
-extern ROCKSDB_LIBRARY_API void
-rocksdb_block_based_options_set_partition_pinning_tier(
-    rocksdb_block_based_table_options_t* options, int v);
-
-extern ROCKSDB_LIBRARY_API void
-rocksdb_block_based_options_set_unpartitioned_pinning_tier(
-    rocksdb_block_based_table_options_t* options, int v);
@@ -1,21 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/generate_c_api.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Source: tools/c_api_gen/spec.json
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/generate_c_api.py
-//     --spec tools/c_api_gen/spec.json --section 'CuckooOptions simple'
-//     --header-out
-//     c_api_gen/c_generated_cuckoo_options_subset.h.inc
-//     --source-out
-//     c_api_gen/c_generated_cuckoo_options_subset.cc.inc
-
-/* CuckooOptions simple */
-
-void rocksdb_cuckoo_options_set_hash_ratio(
-    rocksdb_cuckoo_table_options_t* options, double v) {
-  options->rep.hash_table_ratio = v;
-}
@@ -1,19 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/generate_c_api.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Source: tools/c_api_gen/spec.json
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/generate_c_api.py
-//     --spec tools/c_api_gen/spec.json --section 'CuckooOptions simple'
-//     --header-out
-//     c_api_gen/c_generated_cuckoo_options_subset.h.inc
-//     --source-out
-//     c_api_gen/c_generated_cuckoo_options_subset.cc.inc
-
-/* CuckooOptions simple */
-
-extern ROCKSDB_LIBRARY_API void rocksdb_cuckoo_options_set_hash_ratio(
-    rocksdb_cuckoo_table_options_t* options, double v);
@@ -1,189 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/generate_c_api.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Source: tools/c_api_gen/spec.json
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/generate_c_api.py
-//     --spec tools/c_api_gen/spec.json --section 'DB data operations'
-//     --header-out
-//     c_api_gen/c_generated_db_simple_subset.h.inc
-//     --source-out
-//     c_api_gen/c_generated_db_simple_subset.cc.inc
-
-/* DB data operations */
-
-void rocksdb_put(rocksdb_t* db, const rocksdb_writeoptions_t* options,
-                 const char* key, size_t keylen, const char* val, size_t vallen,
-                 char** errptr) {
-  SaveError(errptr,
-            db->rep->Put(options->rep, Slice(key, keylen), Slice(val, vallen)));
-}
-
-void rocksdb_put_cf(rocksdb_t* db, const rocksdb_writeoptions_t* options,
-                    rocksdb_column_family_handle_t* column_family,
-                    const char* key, size_t keylen, const char* val,
-                    size_t vallen, char** errptr) {
-  SaveError(errptr, db->rep->Put(options->rep, column_family->rep,
-                                 Slice(key, keylen), Slice(val, vallen)));
-}
-
-void rocksdb_delete(rocksdb_t* db, const rocksdb_writeoptions_t* options,
-                    const char* key, size_t keylen, char** errptr) {
-  SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen)));
-}
-
-void rocksdb_delete_cf(rocksdb_t* db, const rocksdb_writeoptions_t* options,
-                       rocksdb_column_family_handle_t* column_family,
-                       const char* key, size_t keylen, char** errptr) {
-  SaveError(errptr, db->rep->Delete(options->rep, column_family->rep,
-                                    Slice(key, keylen)));
-}
-
-void rocksdb_merge(rocksdb_t* db, const rocksdb_writeoptions_t* options,
-                   const char* key, size_t keylen, const char* val,
-                   size_t vallen, char** errptr) {
-  SaveError(errptr, db->rep->Merge(options->rep, Slice(key, keylen),
-                                   Slice(val, vallen)));
-}
-
-void rocksdb_merge_cf(rocksdb_t* db, const rocksdb_writeoptions_t* options,
-                      rocksdb_column_family_handle_t* column_family,
-                      const char* key, size_t keylen, const char* val,
-                      size_t vallen, char** errptr) {
-  SaveError(errptr, db->rep->Merge(options->rep, column_family->rep,
-                                   Slice(key, keylen), Slice(val, vallen)));
-}
-
-void rocksdb_write(rocksdb_t* db, const rocksdb_writeoptions_t* options,
-                   rocksdb_writebatch_t* batch, char** errptr) {
-  SaveError(errptr, db->rep->Write(options->rep, &batch->rep));
-}
-
-void rocksdb_put_with_ts(rocksdb_t* db, const rocksdb_writeoptions_t* options,
-                         const char* key, size_t keylen, const char* ts,
-                         size_t tslen, const char* val, size_t vallen,
-                         char** errptr) {
-  SaveError(errptr, db->rep->Put(options->rep, Slice(key, keylen),
-                                 Slice(ts, tslen), Slice(val, vallen)));
-}
-
-void rocksdb_put_cf_with_ts(rocksdb_t* db,
-                            const rocksdb_writeoptions_t* options,
-                            rocksdb_column_family_handle_t* column_family,
-                            const char* key, size_t keylen, const char* ts,
-                            size_t tslen, const char* val, size_t vallen,
-                            char** errptr) {
-  SaveError(errptr,
-            db->rep->Put(options->rep, column_family->rep, Slice(key, keylen),
-                         Slice(ts, tslen), Slice(val, vallen)));
-}
-
-void rocksdb_delete_with_ts(rocksdb_t* db,
-                            const rocksdb_writeoptions_t* options,
-                            const char* key, size_t keylen, const char* ts,
-                            size_t tslen, char** errptr) {
-  SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen),
-                                    Slice(ts, tslen)));
-}
-
-void rocksdb_delete_cf_with_ts(rocksdb_t* db,
-                               const rocksdb_writeoptions_t* options,
-                               rocksdb_column_family_handle_t* column_family,
-                               const char* key, size_t keylen, const char* ts,
-                               size_t tslen, char** errptr) {
-  SaveError(errptr, db->rep->Delete(options->rep, column_family->rep,
-                                    Slice(key, keylen), Slice(ts, tslen)));
-}
-
-void rocksdb_singledelete(rocksdb_t* db, const rocksdb_writeoptions_t* options,
-                          const char* key, size_t keylen, char** errptr) {
-  SaveError(errptr, db->rep->SingleDelete(options->rep, Slice(key, keylen)));
-}
-
-void rocksdb_singledelete_cf(rocksdb_t* db,
-                             const rocksdb_writeoptions_t* options,
-                             rocksdb_column_family_handle_t* column_family,
-                             const char* key, size_t keylen, char** errptr) {
-  SaveError(errptr, db->rep->SingleDelete(options->rep, column_family->rep,
-                                          Slice(key, keylen)));
-}
-
-void rocksdb_singledelete_with_ts(rocksdb_t* db,
-                                  const rocksdb_writeoptions_t* options,
-                                  const char* key, size_t keylen,
-                                  const char* ts, size_t tslen, char** errptr) {
-  SaveError(errptr, db->rep->SingleDelete(options->rep, Slice(key, keylen),
-                                          Slice(ts, tslen)));
-}
-
-void rocksdb_singledelete_cf_with_ts(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, const char* ts, size_t tslen, char** errptr) {
-  SaveError(errptr,
-            db->rep->SingleDelete(options->rep, column_family->rep,
-                                  Slice(key, keylen), Slice(ts, tslen)));
-}
-
-void rocksdb_delete_range_cf(rocksdb_t* db,
-                             const rocksdb_writeoptions_t* options,
-                             rocksdb_column_family_handle_t* column_family,
-                             const char* start_key, size_t start_key_len,
-                             const char* end_key, size_t end_key_len,
-                             char** errptr) {
-  SaveError(errptr, db->rep->DeleteRange(options->rep, column_family->rep,
-                                         Slice(start_key, start_key_len),
-                                         Slice(end_key, end_key_len)));
-}
-
-void rocksdb_flush(rocksdb_t* db, const rocksdb_flushoptions_t* options,
-                   char** errptr) {
-  SaveError(errptr, db->rep->Flush(options->rep));
-}
-
-void rocksdb_flush_cf(rocksdb_t* db, const rocksdb_flushoptions_t* options,
-                      rocksdb_column_family_handle_t* column_family,
-                      char** errptr) {
-  SaveError(errptr, db->rep->Flush(options->rep, column_family->rep));
-}
-
-void rocksdb_flush_wal(rocksdb_t* db, unsigned char sync, char** errptr) {
-  SaveError(errptr, db->rep->FlushWAL(sync));
-}
-
-void rocksdb_pause_background_work(rocksdb_t* db, char** errptr) {
-  SaveError(errptr, db->rep->PauseBackgroundWork());
-}
-
-void rocksdb_continue_background_work(rocksdb_t* db, char** errptr) {
-  SaveError(errptr, db->rep->ContinueBackgroundWork());
-}
-
-void rocksdb_disable_file_deletions(rocksdb_t* db, char** errptr) {
-  SaveError(errptr, db->rep->DisableFileDeletions());
-}
-
-void rocksdb_enable_file_deletions(rocksdb_t* db, char** errptr) {
-  SaveError(errptr, db->rep->EnableFileDeletions());
-}
-
-void rocksdb_verify_checksum(rocksdb_t* db, char** errptr) {
-  SaveError(errptr, db->rep->VerifyChecksum());
-}
-
-void rocksdb_verify_file_checksums(rocksdb_t* db, char** errptr) {
-  SaveError(errptr, db->rep->VerifyFileChecksums(ReadOptions()));
-}
-
-void rocksdb_destroy_db(const rocksdb_options_t* options, const char* name,
-                        char** errptr) {
-  SaveError(errptr, DestroyDB(name, options->rep));
-}
-
-void rocksdb_repair_db(const rocksdb_options_t* options, const char* name,
-                       char** errptr) {
-  SaveError(errptr, RepairDB(name, options->rep));
-}
@@ -1,126 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/generate_c_api.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Source: tools/c_api_gen/spec.json
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/generate_c_api.py
-//     --spec tools/c_api_gen/spec.json --section 'DB data operations'
-//     --header-out
-//     c_api_gen/c_generated_db_simple_subset.h.inc
-//     --source-out
-//     c_api_gen/c_generated_db_simple_subset.cc.inc
-
-/* DB data operations */
-
-extern ROCKSDB_LIBRARY_API void rocksdb_put(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key,
-    size_t keylen, const char* val, size_t vallen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_put_cf(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, const char* val, size_t vallen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_delete(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key,
-    size_t keylen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_delete_cf(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_merge(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key,
-    size_t keylen, const char* val, size_t vallen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_merge_cf(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, const char* val, size_t vallen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_write(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_writebatch_t* batch, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_put_with_ts(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key,
-    size_t keylen, const char* ts, size_t tslen, const char* val, size_t vallen,
-    char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_put_cf_with_ts(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, const char* ts, size_t tslen, const char* val, size_t vallen,
-    char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_delete_with_ts(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key,
-    size_t keylen, const char* ts, size_t tslen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_delete_cf_with_ts(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, const char* ts, size_t tslen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_singledelete(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key,
-    size_t keylen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_singledelete_cf(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_singledelete_with_ts(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key,
-    size_t keylen, const char* ts, size_t tslen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_singledelete_cf_with_ts(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, const char* ts, size_t tslen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_delete_range_cf(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* start_key,
-    size_t start_key_len, const char* end_key, size_t end_key_len,
-    char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_flush(
-    rocksdb_t* db, const rocksdb_flushoptions_t* options, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_flush_cf(
-    rocksdb_t* db, const rocksdb_flushoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_flush_wal(rocksdb_t* db,
-                                                  unsigned char sync,
-                                                  char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_pause_background_work(rocksdb_t* db,
-                                                              char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_continue_background_work(rocksdb_t* db,
-                                                                 char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_disable_file_deletions(rocksdb_t* db,
-                                                               char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_enable_file_deletions(rocksdb_t* db,
-                                                              char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_verify_checksum(rocksdb_t* db,
-                                                        char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_verify_file_checksums(rocksdb_t* db,
-                                                              char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_destroy_db(
-    const rocksdb_options_t* options, const char* name, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_repair_db(
-    const rocksdb_options_t* options, const char* name, char** errptr);
@@ -1,255 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/auto_simple_bindings.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Sources:
-//   - include/rocksdb/listener.h
-//   - tools/c_api_gen/auto_simple_bindings_blocklist.json
-//   - include/rocksdb/c.h
-//   - tools/c_api_gen/c_base.cc
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/auto_simple_bindings.py
-
-// Output group: Auto-discovered JobInfo metadata simple
-
-/* FlushJobInfo */
-
-uint32_t rocksdb_flushjobinfo_cf_id(const rocksdb_flushjobinfo_t* info) {
-  return info->rep.cf_id;
-}
-
-const char* rocksdb_flushjobinfo_cf_name(const rocksdb_flushjobinfo_t* info,
-                                         size_t* size) {
-  *size = info->rep.cf_name.size();
-  return info->rep.cf_name.data();
-}
-
-const char* rocksdb_flushjobinfo_file_path(const rocksdb_flushjobinfo_t* info,
-                                           size_t* size) {
-  *size = info->rep.file_path.size();
-  return info->rep.file_path.data();
-}
-
-uint64_t rocksdb_flushjobinfo_file_number(const rocksdb_flushjobinfo_t* info) {
-  return info->rep.file_number;
-}
-
-uint64_t rocksdb_flushjobinfo_oldest_blob_file_number(
-    const rocksdb_flushjobinfo_t* info) {
-  return info->rep.oldest_blob_file_number;
-}
-
-uint64_t rocksdb_flushjobinfo_thread_id(const rocksdb_flushjobinfo_t* info) {
-  return info->rep.thread_id;
-}
-
-int rocksdb_flushjobinfo_job_id(const rocksdb_flushjobinfo_t* info) {
-  return info->rep.job_id;
-}
-
-unsigned char rocksdb_flushjobinfo_triggered_writes_slowdown(
-    const rocksdb_flushjobinfo_t* info) {
-  return info->rep.triggered_writes_slowdown;
-}
-
-unsigned char rocksdb_flushjobinfo_triggered_writes_stop(
-    const rocksdb_flushjobinfo_t* info) {
-  return info->rep.triggered_writes_stop;
-}
-
-uint64_t rocksdb_flushjobinfo_smallest_seqno(
-    const rocksdb_flushjobinfo_t* info) {
-  return info->rep.smallest_seqno;
-}
-
-uint64_t rocksdb_flushjobinfo_largest_seqno(
-    const rocksdb_flushjobinfo_t* info) {
-  return info->rep.largest_seqno;
-}
-
-uint32_t rocksdb_flushjobinfo_flush_reason(const rocksdb_flushjobinfo_t* info) {
-  return static_cast<uint32_t>(info->rep.flush_reason);
-}
-
-uint32_t rocksdb_flushjobinfo_blob_compression_type(
-    const rocksdb_flushjobinfo_t* info) {
-  return static_cast<uint32_t>(info->rep.blob_compression_type);
-}
-
-/* CompactionJobInfo */
-
-uint32_t rocksdb_compactionjobinfo_cf_id(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.cf_id;
-}
-
-const char* rocksdb_compactionjobinfo_cf_name(
-    const rocksdb_compactionjobinfo_t* info, size_t* size) {
-  *size = info->rep.cf_name.size();
-  return info->rep.cf_name.data();
-}
-
-void rocksdb_compactionjobinfo_status(const rocksdb_compactionjobinfo_t* info,
-                                      char** errptr) {
-  SaveError(errptr, info->rep.status);
-}
-
-uint64_t rocksdb_compactionjobinfo_thread_id(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.thread_id;
-}
-
-int rocksdb_compactionjobinfo_job_id(const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.job_id;
-}
-
-int rocksdb_compactionjobinfo_num_l0_files(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.num_l0_files;
-}
-
-int rocksdb_compactionjobinfo_base_input_level(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.base_input_level;
-}
-
-int rocksdb_compactionjobinfo_output_level(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.output_level;
-}
-
-uint32_t rocksdb_compactionjobinfo_compaction_reason(
-    const rocksdb_compactionjobinfo_t* info) {
-  return static_cast<uint32_t>(info->rep.compaction_reason);
-}
-
-uint32_t rocksdb_compactionjobinfo_compression(
-    const rocksdb_compactionjobinfo_t* info) {
-  return static_cast<uint32_t>(info->rep.compression);
-}
-
-uint32_t rocksdb_compactionjobinfo_blob_compression_type(
-    const rocksdb_compactionjobinfo_t* info) {
-  return static_cast<uint32_t>(info->rep.blob_compression_type);
-}
-
-unsigned char rocksdb_compactionjobinfo_aborted(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.aborted;
-}
-
-/* SubcompactionJobInfo */
-
-uint32_t rocksdb_subcompactionjobinfo_cf_id(
-    const rocksdb_subcompactionjobinfo_t* info) {
-  return info->rep.cf_id;
-}
-
-const char* rocksdb_subcompactionjobinfo_cf_name(
-    const rocksdb_subcompactionjobinfo_t* info, size_t* size) {
-  *size = info->rep.cf_name.size();
-  return info->rep.cf_name.data();
-}
-
-void rocksdb_subcompactionjobinfo_status(
-    const rocksdb_subcompactionjobinfo_t* info, char** errptr) {
-  SaveError(errptr, info->rep.status);
-}
-
-uint64_t rocksdb_subcompactionjobinfo_thread_id(
-    const rocksdb_subcompactionjobinfo_t* info) {
-  return info->rep.thread_id;
-}
-
-int rocksdb_subcompactionjobinfo_job_id(
-    const rocksdb_subcompactionjobinfo_t* info) {
-  return info->rep.job_id;
-}
-
-int rocksdb_subcompactionjobinfo_subcompaction_job_id(
-    const rocksdb_subcompactionjobinfo_t* info) {
-  return info->rep.subcompaction_job_id;
-}
-
-int rocksdb_subcompactionjobinfo_base_input_level(
-    const rocksdb_subcompactionjobinfo_t* info) {
-  return info->rep.base_input_level;
-}
-
-int rocksdb_subcompactionjobinfo_output_level(
-    const rocksdb_subcompactionjobinfo_t* info) {
-  return info->rep.output_level;
-}
-
-uint32_t rocksdb_subcompactionjobinfo_compaction_reason(
-    const rocksdb_subcompactionjobinfo_t* info) {
-  return static_cast<uint32_t>(info->rep.compaction_reason);
-}
-
-uint32_t rocksdb_subcompactionjobinfo_compression(
-    const rocksdb_subcompactionjobinfo_t* info) {
-  return static_cast<uint32_t>(info->rep.compression);
-}
-
-uint32_t rocksdb_subcompactionjobinfo_blob_compression_type(
-    const rocksdb_subcompactionjobinfo_t* info) {
-  return static_cast<uint32_t>(info->rep.blob_compression_type);
-}
-
-/* ExternalFileIngestionInfo */
-
-const char* rocksdb_externalfileingestioninfo_cf_name(
-    const rocksdb_externalfileingestioninfo_t* info, size_t* size) {
-  *size = info->rep.cf_name.size();
-  return info->rep.cf_name.data();
-}
-
-const char* rocksdb_externalfileingestioninfo_external_file_path(
-    const rocksdb_externalfileingestioninfo_t* info, size_t* size) {
-  *size = info->rep.external_file_path.size();
-  return info->rep.external_file_path.data();
-}
-
-const char* rocksdb_externalfileingestioninfo_internal_file_path(
-    const rocksdb_externalfileingestioninfo_t* info, size_t* size) {
-  *size = info->rep.internal_file_path.size();
-  return info->rep.internal_file_path.data();
-}
-
-uint64_t rocksdb_externalfileingestioninfo_global_seqno(
-    const rocksdb_externalfileingestioninfo_t* info) {
-  return info->rep.global_seqno;
-}
-
-/* MemTableInfo */
-
-const char* rocksdb_memtableinfo_cf_name(const rocksdb_memtableinfo_t* info,
-                                         size_t* size) {
-  *size = info->rep.cf_name.size();
-  return info->rep.cf_name.data();
-}
-
-uint64_t rocksdb_memtableinfo_first_seqno(const rocksdb_memtableinfo_t* info) {
-  return info->rep.first_seqno;
-}
-
-uint64_t rocksdb_memtableinfo_earliest_seqno(
-    const rocksdb_memtableinfo_t* info) {
-  return info->rep.earliest_seqno;
-}
-
-uint64_t rocksdb_memtableinfo_num_entries(const rocksdb_memtableinfo_t* info) {
-  return info->rep.num_entries;
-}
-
-uint64_t rocksdb_memtableinfo_num_deletes(const rocksdb_memtableinfo_t* info) {
-  return info->rep.num_deletes;
-}
-
-const char* rocksdb_memtableinfo_newest_udt(const rocksdb_memtableinfo_t* info,
-                                            size_t* size) {
-  *size = info->rep.newest_udt.size();
-  return info->rep.newest_udt.data();
-}
@@ -1,173 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/auto_simple_bindings.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Sources:
-//   - include/rocksdb/listener.h
-//   - tools/c_api_gen/auto_simple_bindings_blocklist.json
-//   - include/rocksdb/c.h
-//   - tools/c_api_gen/c_base.cc
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/auto_simple_bindings.py
-
-// Output group: Auto-discovered JobInfo metadata simple
-
-/* FlushJobInfo */
-
-extern ROCKSDB_LIBRARY_API uint32_t
-rocksdb_flushjobinfo_cf_id(const rocksdb_flushjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API const char* rocksdb_flushjobinfo_cf_name(
-    const rocksdb_flushjobinfo_t* info, size_t* size);
-
-extern ROCKSDB_LIBRARY_API const char* rocksdb_flushjobinfo_file_path(
-    const rocksdb_flushjobinfo_t* info, size_t* size);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_flushjobinfo_file_number(const rocksdb_flushjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_flushjobinfo_oldest_blob_file_number(
-    const rocksdb_flushjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_flushjobinfo_thread_id(const rocksdb_flushjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API int rocksdb_flushjobinfo_job_id(
-    const rocksdb_flushjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API unsigned char
-rocksdb_flushjobinfo_triggered_writes_slowdown(
-    const rocksdb_flushjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API unsigned char
-rocksdb_flushjobinfo_triggered_writes_stop(const rocksdb_flushjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_flushjobinfo_smallest_seqno(const rocksdb_flushjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_flushjobinfo_largest_seqno(const rocksdb_flushjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint32_t
-rocksdb_flushjobinfo_flush_reason(const rocksdb_flushjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint32_t
-rocksdb_flushjobinfo_blob_compression_type(const rocksdb_flushjobinfo_t* info);
-
-/* CompactionJobInfo */
-
-extern ROCKSDB_LIBRARY_API uint32_t
-rocksdb_compactionjobinfo_cf_id(const rocksdb_compactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API const char* rocksdb_compactionjobinfo_cf_name(
-    const rocksdb_compactionjobinfo_t* info, size_t* size);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_compactionjobinfo_status(
-    const rocksdb_compactionjobinfo_t* info, char** errptr);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compactionjobinfo_thread_id(const rocksdb_compactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API int rocksdb_compactionjobinfo_job_id(
-    const rocksdb_compactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API int rocksdb_compactionjobinfo_num_l0_files(
-    const rocksdb_compactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API int rocksdb_compactionjobinfo_base_input_level(
-    const rocksdb_compactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API int rocksdb_compactionjobinfo_output_level(
-    const rocksdb_compactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint32_t rocksdb_compactionjobinfo_compaction_reason(
-    const rocksdb_compactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint32_t
-rocksdb_compactionjobinfo_compression(const rocksdb_compactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint32_t
-rocksdb_compactionjobinfo_blob_compression_type(
-    const rocksdb_compactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API unsigned char rocksdb_compactionjobinfo_aborted(
-    const rocksdb_compactionjobinfo_t* info);
-
-/* SubcompactionJobInfo */
-
-extern ROCKSDB_LIBRARY_API uint32_t
-rocksdb_subcompactionjobinfo_cf_id(const rocksdb_subcompactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API const char* rocksdb_subcompactionjobinfo_cf_name(
-    const rocksdb_subcompactionjobinfo_t* info, size_t* size);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_subcompactionjobinfo_status(
-    const rocksdb_subcompactionjobinfo_t* info, char** errptr);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_subcompactionjobinfo_thread_id(
-    const rocksdb_subcompactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API int rocksdb_subcompactionjobinfo_job_id(
-    const rocksdb_subcompactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API int
-rocksdb_subcompactionjobinfo_subcompaction_job_id(
-    const rocksdb_subcompactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API int rocksdb_subcompactionjobinfo_base_input_level(
-    const rocksdb_subcompactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API int rocksdb_subcompactionjobinfo_output_level(
-    const rocksdb_subcompactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint32_t
-rocksdb_subcompactionjobinfo_compaction_reason(
-    const rocksdb_subcompactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint32_t rocksdb_subcompactionjobinfo_compression(
-    const rocksdb_subcompactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint32_t
-rocksdb_subcompactionjobinfo_blob_compression_type(
-    const rocksdb_subcompactionjobinfo_t* info);
-
-/* ExternalFileIngestionInfo */
-
-extern ROCKSDB_LIBRARY_API const char*
-rocksdb_externalfileingestioninfo_cf_name(
-    const rocksdb_externalfileingestioninfo_t* info, size_t* size);
-
-extern ROCKSDB_LIBRARY_API const char*
-rocksdb_externalfileingestioninfo_external_file_path(
-    const rocksdb_externalfileingestioninfo_t* info, size_t* size);
-
-extern ROCKSDB_LIBRARY_API const char*
-rocksdb_externalfileingestioninfo_internal_file_path(
-    const rocksdb_externalfileingestioninfo_t* info, size_t* size);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_externalfileingestioninfo_global_seqno(
-    const rocksdb_externalfileingestioninfo_t* info);
-
-/* MemTableInfo */
-
-extern ROCKSDB_LIBRARY_API const char* rocksdb_memtableinfo_cf_name(
-    const rocksdb_memtableinfo_t* info, size_t* size);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_memtableinfo_first_seqno(const rocksdb_memtableinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_memtableinfo_earliest_seqno(const rocksdb_memtableinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_memtableinfo_num_entries(const rocksdb_memtableinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_memtableinfo_num_deletes(const rocksdb_memtableinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API const char* rocksdb_memtableinfo_newest_udt(
-    const rocksdb_memtableinfo_t* info, size_t* size);
@@ -1,84 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/generate_c_api.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Source: tools/c_api_gen/spec.json
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/generate_c_api.py
-//     --spec tools/c_api_gen/spec.json --section 'JobInfo metadata simple'
-//     --header-out
-//     c_api_gen/c_generated_jobinfo_metadata_subset.h.inc
-//     --source-out
-//     c_api_gen/c_generated_jobinfo_metadata_subset.cc.inc
-
-/* JobInfo metadata simple */
-
-size_t rocksdb_compactionjobinfo_input_files_count(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.input_files.size();
-}
-
-size_t rocksdb_compactionjobinfo_output_files_count(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.output_files.size();
-}
-
-uint64_t rocksdb_compactionjobinfo_elapsed_micros(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.stats.elapsed_micros;
-}
-
-uint64_t rocksdb_compactionjobinfo_num_corrupt_keys(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.stats.num_corrupt_keys;
-}
-
-uint64_t rocksdb_compactionjobinfo_input_records(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.stats.num_input_records;
-}
-
-uint64_t rocksdb_compactionjobinfo_output_records(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.stats.num_output_records;
-}
-
-uint64_t rocksdb_compactionjobinfo_total_input_bytes(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.stats.total_input_bytes;
-}
-
-uint64_t rocksdb_compactionjobinfo_total_output_bytes(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.stats.total_output_bytes;
-}
-
-size_t rocksdb_compactionjobinfo_num_input_files(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.stats.num_input_files;
-}
-
-size_t rocksdb_compactionjobinfo_num_input_files_at_output_level(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.stats.num_input_files_at_output_level;
-}
-
-const char* rocksdb_writestallinfo_cf_name(const rocksdb_writestallinfo_t* info,
-                                           size_t* size) {
-  *size = info->rep.cf_name.size();
-  return info->rep.cf_name.data();
-}
-
-const rocksdb_writestallcondition_t* rocksdb_writestallinfo_cur(
-    const rocksdb_writestallinfo_t* info) {
-  return reinterpret_cast<const rocksdb_writestallcondition_t*>(
-      &info->rep.condition.cur);
-}
-
-const rocksdb_writestallcondition_t* rocksdb_writestallinfo_prev(
-    const rocksdb_writestallinfo_t* info) {
-  return reinterpret_cast<const rocksdb_writestallcondition_t*>(
-      &info->rep.condition.prev);
-}
@@ -1,57 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/generate_c_api.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Source: tools/c_api_gen/spec.json
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/generate_c_api.py
-//     --spec tools/c_api_gen/spec.json --section 'JobInfo metadata simple'
-//     --header-out
-//     c_api_gen/c_generated_jobinfo_metadata_subset.h.inc
-//     --source-out
-//     c_api_gen/c_generated_jobinfo_metadata_subset.cc.inc
-
-/* JobInfo metadata simple */
-
-extern ROCKSDB_LIBRARY_API size_t rocksdb_compactionjobinfo_input_files_count(
-    const rocksdb_compactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API size_t rocksdb_compactionjobinfo_output_files_count(
-    const rocksdb_compactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compactionjobinfo_elapsed_micros(
-    const rocksdb_compactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compactionjobinfo_num_corrupt_keys(
-    const rocksdb_compactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compactionjobinfo_input_records(
-    const rocksdb_compactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compactionjobinfo_output_records(
-    const rocksdb_compactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compactionjobinfo_total_input_bytes(
-    const rocksdb_compactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compactionjobinfo_total_output_bytes(
-    const rocksdb_compactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API size_t rocksdb_compactionjobinfo_num_input_files(
-    const rocksdb_compactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API size_t
-rocksdb_compactionjobinfo_num_input_files_at_output_level(
-    const rocksdb_compactionjobinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API const char* rocksdb_writestallinfo_cf_name(
-    const rocksdb_writestallinfo_t* info, size_t* size);
-
-extern ROCKSDB_LIBRARY_API const rocksdb_writestallcondition_t*
-rocksdb_writestallinfo_cur(const rocksdb_writestallinfo_t* info);
-
-extern ROCKSDB_LIBRARY_API const rocksdb_writestallcondition_t*
-rocksdb_writestallinfo_prev(const rocksdb_writestallinfo_t* info);
@@ -1,501 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/auto_simple_bindings.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Sources:
-//   - include/rocksdb/compaction_job_stats.h
-//   - include/rocksdb/listener.h
-//   - include/rocksdb/table_properties.h
-//   - tools/c_api_gen/auto_simple_bindings_blocklist.json
-//   - include/rocksdb/c.h
-//   - tools/c_api_gen/c_base.cc
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/auto_simple_bindings.py
-
-// Output group: Auto-discovered metadata view structs simple
-
-/* TableProperties */
-
-uint64_t rocksdb_table_properties_orig_file_number(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.orig_file_number;
-}
-
-uint64_t rocksdb_table_properties_data_size(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.data_size;
-}
-
-uint64_t rocksdb_table_properties_uncompressed_data_size(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.uncompressed_data_size;
-}
-
-uint64_t rocksdb_table_properties_index_size(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.index_size;
-}
-
-uint64_t rocksdb_table_properties_index_partitions(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.index_partitions;
-}
-
-uint64_t rocksdb_table_properties_top_level_index_size(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.top_level_index_size;
-}
-
-uint64_t rocksdb_table_properties_index_key_is_user_key(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.index_key_is_user_key;
-}
-
-uint64_t rocksdb_table_properties_index_value_is_delta_encoded(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.index_value_is_delta_encoded;
-}
-
-uint64_t rocksdb_table_properties_udi_is_primary_index(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.udi_is_primary_index;
-}
-
-uint64_t rocksdb_table_properties_filter_size(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.filter_size;
-}
-
-uint64_t rocksdb_table_properties_raw_key_size(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.raw_key_size;
-}
-
-uint64_t rocksdb_table_properties_raw_value_size(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.raw_value_size;
-}
-
-uint64_t rocksdb_table_properties_num_data_blocks(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.num_data_blocks;
-}
-
-uint64_t rocksdb_table_properties_num_data_blocks_compression_rejected(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.num_data_blocks_compression_rejected;
-}
-
-uint64_t rocksdb_table_properties_num_data_blocks_compression_bypassed(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.num_data_blocks_compression_bypassed;
-}
-
-uint64_t rocksdb_table_properties_num_uniform_blocks(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.num_uniform_blocks;
-}
-
-uint64_t rocksdb_table_properties_num_entries(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.num_entries;
-}
-
-uint64_t rocksdb_table_properties_num_filter_entries(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.num_filter_entries;
-}
-
-uint64_t rocksdb_table_properties_num_deletions(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.num_deletions;
-}
-
-uint64_t rocksdb_table_properties_num_merge_operands(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.num_merge_operands;
-}
-
-uint64_t rocksdb_table_properties_num_range_deletions(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.num_range_deletions;
-}
-
-uint64_t rocksdb_table_properties_format_version(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.format_version;
-}
-
-uint64_t rocksdb_table_properties_fixed_key_len(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.fixed_key_len;
-}
-
-uint64_t rocksdb_table_properties_column_family_id(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.column_family_id;
-}
-
-uint64_t rocksdb_table_properties_creation_time(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.creation_time;
-}
-
-uint64_t rocksdb_table_properties_oldest_key_time(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.oldest_key_time;
-}
-
-uint64_t rocksdb_table_properties_newest_key_time(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.newest_key_time;
-}
-
-uint64_t rocksdb_table_properties_file_creation_time(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.file_creation_time;
-}
-
-uint64_t rocksdb_table_properties_slow_compression_estimated_data_size(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.slow_compression_estimated_data_size;
-}
-
-uint64_t rocksdb_table_properties_fast_compression_estimated_data_size(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.fast_compression_estimated_data_size;
-}
-
-uint64_t rocksdb_table_properties_external_sst_file_global_seqno_offset(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.external_sst_file_global_seqno_offset;
-}
-
-uint64_t rocksdb_table_properties_tail_start_offset(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.tail_start_offset;
-}
-
-uint64_t rocksdb_table_properties_user_defined_timestamps_persisted(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.user_defined_timestamps_persisted;
-}
-
-uint64_t rocksdb_table_properties_key_largest_seqno(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.key_largest_seqno;
-}
-
-uint64_t rocksdb_table_properties_key_smallest_seqno(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.key_smallest_seqno;
-}
-
-uint64_t rocksdb_table_properties_data_block_restart_interval(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.data_block_restart_interval;
-}
-
-uint64_t rocksdb_table_properties_index_block_restart_interval(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.index_block_restart_interval;
-}
-
-uint64_t rocksdb_table_properties_separate_key_value_in_data_block(
-    const rocksdb_table_properties_t* props) {
-  return props->rep.separate_key_value_in_data_block;
-}
-
-const char* rocksdb_table_properties_db_id(
-    const rocksdb_table_properties_t* props, size_t* size) {
-  *size = props->rep.db_id.size();
-  return props->rep.db_id.data();
-}
-
-const char* rocksdb_table_properties_db_session_id(
-    const rocksdb_table_properties_t* props, size_t* size) {
-  *size = props->rep.db_session_id.size();
-  return props->rep.db_session_id.data();
-}
-
-const char* rocksdb_table_properties_db_host_id(
-    const rocksdb_table_properties_t* props, size_t* size) {
-  *size = props->rep.db_host_id.size();
-  return props->rep.db_host_id.data();
-}
-
-const char* rocksdb_table_properties_column_family_name(
-    const rocksdb_table_properties_t* props, size_t* size) {
-  *size = props->rep.column_family_name.size();
-  return props->rep.column_family_name.data();
-}
-
-const char* rocksdb_table_properties_filter_policy_name(
-    const rocksdb_table_properties_t* props, size_t* size) {
-  *size = props->rep.filter_policy_name.size();
-  return props->rep.filter_policy_name.data();
-}
-
-const char* rocksdb_table_properties_comparator_name(
-    const rocksdb_table_properties_t* props, size_t* size) {
-  *size = props->rep.comparator_name.size();
-  return props->rep.comparator_name.data();
-}
-
-const char* rocksdb_table_properties_merge_operator_name(
-    const rocksdb_table_properties_t* props, size_t* size) {
-  *size = props->rep.merge_operator_name.size();
-  return props->rep.merge_operator_name.data();
-}
-
-const char* rocksdb_table_properties_prefix_extractor_name(
-    const rocksdb_table_properties_t* props, size_t* size) {
-  *size = props->rep.prefix_extractor_name.size();
-  return props->rep.prefix_extractor_name.data();
-}
-
-const char* rocksdb_table_properties_property_collectors_names(
-    const rocksdb_table_properties_t* props, size_t* size) {
-  *size = props->rep.property_collectors_names.size();
-  return props->rep.property_collectors_names.data();
-}
-
-const char* rocksdb_table_properties_compression_name(
-    const rocksdb_table_properties_t* props, size_t* size) {
-  *size = props->rep.compression_name.size();
-  return props->rep.compression_name.data();
-}
-
-const char* rocksdb_table_properties_compression_options(
-    const rocksdb_table_properties_t* props, size_t* size) {
-  *size = props->rep.compression_options.size();
-  return props->rep.compression_options.data();
-}
-
-const char* rocksdb_table_properties_seqno_to_time_mapping(
-    const rocksdb_table_properties_t* props, size_t* size) {
-  *size = props->rep.seqno_to_time_mapping.size();
-  return props->rep.seqno_to_time_mapping.data();
-}
-
-/* CompactionJobStats */
-
-uint64_t rocksdb_compaction_job_stats_elapsed_micros(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.elapsed_micros;
-}
-
-uint64_t rocksdb_compaction_job_stats_cpu_micros(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.cpu_micros;
-}
-
-unsigned char rocksdb_compaction_job_stats_has_accurate_num_input_records(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.has_accurate_num_input_records;
-}
-
-uint64_t rocksdb_compaction_job_stats_num_input_records(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.num_input_records;
-}
-
-uint64_t rocksdb_compaction_job_stats_num_blobs_read(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.num_blobs_read;
-}
-
-size_t rocksdb_compaction_job_stats_num_input_files(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.num_input_files;
-}
-
-size_t rocksdb_compaction_job_stats_num_input_files_trivially_moved(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.num_input_files_trivially_moved;
-}
-
-size_t rocksdb_compaction_job_stats_num_input_files_at_output_level(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.num_input_files_at_output_level;
-}
-
-size_t rocksdb_compaction_job_stats_num_filtered_input_files(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.num_filtered_input_files;
-}
-
-size_t rocksdb_compaction_job_stats_num_filtered_input_files_at_output_level(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.num_filtered_input_files_at_output_level;
-}
-
-uint64_t rocksdb_compaction_job_stats_num_output_records(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.num_output_records;
-}
-
-size_t rocksdb_compaction_job_stats_num_output_files(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.num_output_files;
-}
-
-size_t rocksdb_compaction_job_stats_num_output_files_blob(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.num_output_files_blob;
-}
-
-unsigned char rocksdb_compaction_job_stats_is_full_compaction(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.is_full_compaction;
-}
-
-unsigned char rocksdb_compaction_job_stats_is_manual_compaction(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.is_manual_compaction;
-}
-
-unsigned char rocksdb_compaction_job_stats_is_remote_compaction(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.is_remote_compaction;
-}
-
-uint64_t rocksdb_compaction_job_stats_total_input_bytes(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.total_input_bytes;
-}
-
-uint64_t rocksdb_compaction_job_stats_total_blob_bytes_read(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.total_blob_bytes_read;
-}
-
-uint64_t rocksdb_compaction_job_stats_total_output_bytes(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.total_output_bytes;
-}
-
-uint64_t rocksdb_compaction_job_stats_total_output_bytes_blob(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.total_output_bytes_blob;
-}
-
-uint64_t rocksdb_compaction_job_stats_total_skipped_input_bytes(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.total_skipped_input_bytes;
-}
-
-uint64_t rocksdb_compaction_job_stats_num_records_replaced(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.num_records_replaced;
-}
-
-uint64_t rocksdb_compaction_job_stats_total_input_raw_key_bytes(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.total_input_raw_key_bytes;
-}
-
-uint64_t rocksdb_compaction_job_stats_total_input_raw_value_bytes(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.total_input_raw_value_bytes;
-}
-
-uint64_t rocksdb_compaction_job_stats_num_input_deletion_records(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.num_input_deletion_records;
-}
-
-uint64_t rocksdb_compaction_job_stats_num_expired_deletion_records(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.num_expired_deletion_records;
-}
-
-uint64_t rocksdb_compaction_job_stats_num_corrupt_keys(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.num_corrupt_keys;
-}
-
-uint64_t rocksdb_compaction_job_stats_file_write_nanos(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.file_write_nanos;
-}
-
-uint64_t rocksdb_compaction_job_stats_file_range_sync_nanos(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.file_range_sync_nanos;
-}
-
-uint64_t rocksdb_compaction_job_stats_file_fsync_nanos(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.file_fsync_nanos;
-}
-
-uint64_t rocksdb_compaction_job_stats_file_prepare_write_nanos(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.file_prepare_write_nanos;
-}
-
-const char* rocksdb_compaction_job_stats_smallest_output_key_prefix(
-    const rocksdb_compaction_job_stats_t* stats, size_t* size) {
-  *size = stats->rep.smallest_output_key_prefix.size();
-  return stats->rep.smallest_output_key_prefix.data();
-}
-
-const char* rocksdb_compaction_job_stats_largest_output_key_prefix(
-    const rocksdb_compaction_job_stats_t* stats, size_t* size) {
-  *size = stats->rep.largest_output_key_prefix.size();
-  return stats->rep.largest_output_key_prefix.data();
-}
-
-uint64_t rocksdb_compaction_job_stats_num_single_del_fallthru(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.num_single_del_fallthru;
-}
-
-uint64_t rocksdb_compaction_job_stats_num_single_del_mismatch(
-    const rocksdb_compaction_job_stats_t* stats) {
-  return stats->rep.num_single_del_mismatch;
-}
-
-/* CompactionFileInfo */
-
-int rocksdb_compaction_file_info_level(
-    const rocksdb_compaction_file_info_t* info) {
-  return info->rep.level;
-}
-
-uint64_t rocksdb_compaction_file_info_file_number(
-    const rocksdb_compaction_file_info_t* info) {
-  return info->rep.file_number;
-}
-
-uint64_t rocksdb_compaction_file_info_oldest_blob_file_number(
-    const rocksdb_compaction_file_info_t* info) {
-  return info->rep.oldest_blob_file_number;
-}
-
-/* BlobFileAdditionInfo */
-
-uint64_t rocksdb_blob_file_addition_info_total_blob_count(
-    const rocksdb_blob_file_addition_info_t* info) {
-  return info->rep.total_blob_count;
-}
-
-uint64_t rocksdb_blob_file_addition_info_total_blob_bytes(
-    const rocksdb_blob_file_addition_info_t* info) {
-  return info->rep.total_blob_bytes;
-}
-
-/* BlobFileGarbageInfo */
-
-uint64_t rocksdb_blob_file_garbage_info_garbage_blob_count(
-    const rocksdb_blob_file_garbage_info_t* info) {
-  return info->rep.garbage_blob_count;
-}
-
-uint64_t rocksdb_blob_file_garbage_info_garbage_blob_bytes(
-    const rocksdb_blob_file_garbage_info_t* info) {
-  return info->rep.garbage_blob_bytes;
-}
@@ -1,361 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/auto_simple_bindings.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Sources:
-//   - include/rocksdb/compaction_job_stats.h
-//   - include/rocksdb/listener.h
-//   - include/rocksdb/table_properties.h
-//   - tools/c_api_gen/auto_simple_bindings_blocklist.json
-//   - include/rocksdb/c.h
-//   - tools/c_api_gen/c_base.cc
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/auto_simple_bindings.py
-
-// Output group: Auto-discovered metadata view structs simple
-
-/* TableProperties */
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_orig_file_number(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_data_size(const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_uncompressed_data_size(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_index_size(const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_index_partitions(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_top_level_index_size(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_index_key_is_user_key(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_index_value_is_delta_encoded(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_udi_is_primary_index(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_filter_size(const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_raw_key_size(const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_raw_value_size(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_num_data_blocks(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_num_data_blocks_compression_rejected(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_num_data_blocks_compression_bypassed(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_num_uniform_blocks(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_num_entries(const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_num_filter_entries(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_num_deletions(const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_num_merge_operands(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_num_range_deletions(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_format_version(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_fixed_key_len(const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_column_family_id(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_creation_time(const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_oldest_key_time(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_newest_key_time(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_file_creation_time(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_slow_compression_estimated_data_size(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_fast_compression_estimated_data_size(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_external_sst_file_global_seqno_offset(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_tail_start_offset(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_user_defined_timestamps_persisted(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_key_largest_seqno(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_key_smallest_seqno(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_data_block_restart_interval(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_index_block_restart_interval(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_table_properties_separate_key_value_in_data_block(
-    const rocksdb_table_properties_t* props);
-
-extern ROCKSDB_LIBRARY_API const char* rocksdb_table_properties_db_id(
-    const rocksdb_table_properties_t* props, size_t* size);
-
-extern ROCKSDB_LIBRARY_API const char* rocksdb_table_properties_db_session_id(
-    const rocksdb_table_properties_t* props, size_t* size);
-
-extern ROCKSDB_LIBRARY_API const char* rocksdb_table_properties_db_host_id(
-    const rocksdb_table_properties_t* props, size_t* size);
-
-extern ROCKSDB_LIBRARY_API const char*
-rocksdb_table_properties_column_family_name(
-    const rocksdb_table_properties_t* props, size_t* size);
-
-extern ROCKSDB_LIBRARY_API const char*
-rocksdb_table_properties_filter_policy_name(
-    const rocksdb_table_properties_t* props, size_t* size);
-
-extern ROCKSDB_LIBRARY_API const char* rocksdb_table_properties_comparator_name(
-    const rocksdb_table_properties_t* props, size_t* size);
-
-extern ROCKSDB_LIBRARY_API const char*
-rocksdb_table_properties_merge_operator_name(
-    const rocksdb_table_properties_t* props, size_t* size);
-
-extern ROCKSDB_LIBRARY_API const char*
-rocksdb_table_properties_prefix_extractor_name(
-    const rocksdb_table_properties_t* props, size_t* size);
-
-extern ROCKSDB_LIBRARY_API const char*
-rocksdb_table_properties_property_collectors_names(
-    const rocksdb_table_properties_t* props, size_t* size);
-
-extern ROCKSDB_LIBRARY_API const char*
-rocksdb_table_properties_compression_name(
-    const rocksdb_table_properties_t* props, size_t* size);
-
-extern ROCKSDB_LIBRARY_API const char*
-rocksdb_table_properties_compression_options(
-    const rocksdb_table_properties_t* props, size_t* size);
-
-extern ROCKSDB_LIBRARY_API const char*
-rocksdb_table_properties_seqno_to_time_mapping(
-    const rocksdb_table_properties_t* props, size_t* size);
-
-/* CompactionJobStats */
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compaction_job_stats_elapsed_micros(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compaction_job_stats_cpu_micros(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API unsigned char
-rocksdb_compaction_job_stats_has_accurate_num_input_records(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compaction_job_stats_num_input_records(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compaction_job_stats_num_blobs_read(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API size_t rocksdb_compaction_job_stats_num_input_files(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API size_t
-rocksdb_compaction_job_stats_num_input_files_trivially_moved(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API size_t
-rocksdb_compaction_job_stats_num_input_files_at_output_level(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API size_t
-rocksdb_compaction_job_stats_num_filtered_input_files(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API size_t
-rocksdb_compaction_job_stats_num_filtered_input_files_at_output_level(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compaction_job_stats_num_output_records(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API size_t rocksdb_compaction_job_stats_num_output_files(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API size_t
-rocksdb_compaction_job_stats_num_output_files_blob(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API unsigned char
-rocksdb_compaction_job_stats_is_full_compaction(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API unsigned char
-rocksdb_compaction_job_stats_is_manual_compaction(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API unsigned char
-rocksdb_compaction_job_stats_is_remote_compaction(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compaction_job_stats_total_input_bytes(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compaction_job_stats_total_blob_bytes_read(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compaction_job_stats_total_output_bytes(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compaction_job_stats_total_output_bytes_blob(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compaction_job_stats_total_skipped_input_bytes(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compaction_job_stats_num_records_replaced(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compaction_job_stats_total_input_raw_key_bytes(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compaction_job_stats_total_input_raw_value_bytes(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compaction_job_stats_num_input_deletion_records(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compaction_job_stats_num_expired_deletion_records(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compaction_job_stats_num_corrupt_keys(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compaction_job_stats_file_write_nanos(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compaction_job_stats_file_range_sync_nanos(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compaction_job_stats_file_fsync_nanos(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compaction_job_stats_file_prepare_write_nanos(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API const char*
-rocksdb_compaction_job_stats_smallest_output_key_prefix(
-    const rocksdb_compaction_job_stats_t* stats, size_t* size);
-
-extern ROCKSDB_LIBRARY_API const char*
-rocksdb_compaction_job_stats_largest_output_key_prefix(
-    const rocksdb_compaction_job_stats_t* stats, size_t* size);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compaction_job_stats_num_single_del_fallthru(
-    const rocksdb_compaction_job_stats_t* stats);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compaction_job_stats_num_single_del_mismatch(
-    const rocksdb_compaction_job_stats_t* stats);
-
-/* CompactionFileInfo */
-
-extern ROCKSDB_LIBRARY_API int rocksdb_compaction_file_info_level(
-    const rocksdb_compaction_file_info_t* info);
-
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compaction_file_info_file_number(
-    const rocksdb_compaction_file_info_t* info);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_compaction_file_info_oldest_blob_file_number(
-    const rocksdb_compaction_file_info_t* info);
-
-/* BlobFileAdditionInfo */
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_blob_file_addition_info_total_blob_count(
-    const rocksdb_blob_file_addition_info_t* info);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_blob_file_addition_info_total_blob_bytes(
-    const rocksdb_blob_file_addition_info_t* info);
-
-/* BlobFileGarbageInfo */
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_blob_file_garbage_info_garbage_blob_count(
-    const rocksdb_blob_file_garbage_info_t* info);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_blob_file_garbage_info_garbage_blob_bytes(
-    const rocksdb_blob_file_garbage_info_t* info);
@@ -1,84 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/generate_c_api.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Source: tools/c_api_gen/spec.json
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/generate_c_api.py
-//     --spec tools/c_api_gen/spec.json --section 'Options simple'
-//     --header-out
-//     c_api_gen/c_generated_options_subset.h.inc
-//     --source-out
-//     c_api_gen/c_generated_options_subset.cc.inc
-
-/* Options simple */
-
-void rocksdb_options_set_compression_options_zstd_max_train_bytes(
-    rocksdb_options_t* opt, int zstd_max_train_bytes) {
-  opt->rep.compression_opts.zstd_max_train_bytes = zstd_max_train_bytes;
-}
-
-int rocksdb_options_get_compression_options_zstd_max_train_bytes(
-    rocksdb_options_t* opt) {
-  return opt->rep.compression_opts.zstd_max_train_bytes;
-}
-
-void rocksdb_options_set_compression_options_use_zstd_dict_trainer(
-    rocksdb_options_t* opt, unsigned char use_zstd_dict_trainer) {
-  opt->rep.compression_opts.use_zstd_dict_trainer = use_zstd_dict_trainer;
-}
-
-unsigned char rocksdb_options_get_compression_options_use_zstd_dict_trainer(
-    rocksdb_options_t* opt) {
-  return opt->rep.compression_opts.use_zstd_dict_trainer;
-}
-
-void rocksdb_options_set_compression_options_parallel_threads(
-    rocksdb_options_t* opt, int value) {
-  opt->rep.compression_opts.parallel_threads = value;
-}
-
-int rocksdb_options_get_compression_options_parallel_threads(
-    rocksdb_options_t* opt) {
-  return opt->rep.compression_opts.parallel_threads;
-}
-
-void rocksdb_options_set_compression_options_max_dict_buffer_bytes(
-    rocksdb_options_t* opt, uint64_t max_dict_buffer_bytes) {
-  opt->rep.compression_opts.max_dict_buffer_bytes = max_dict_buffer_bytes;
-}
-
-uint64_t rocksdb_options_get_compression_options_max_dict_buffer_bytes(
-    rocksdb_options_t* opt) {
-  return opt->rep.compression_opts.max_dict_buffer_bytes;
-}
-
-unsigned char
-rocksdb_options_get_bottommost_compression_options_use_zstd_dict_trainer(
-    rocksdb_options_t* opt) {
-  return opt->rep.bottommost_compression_opts.use_zstd_dict_trainer;
-}
-
-void rocksdb_options_set_use_fsync(rocksdb_options_t* opt, int use_fsync) {
-  opt->rep.use_fsync = use_fsync;
-}
-
-int rocksdb_options_get_use_fsync(rocksdb_options_t* opt) {
-  return opt->rep.use_fsync;
-}
-
-void rocksdb_options_set_disable_auto_compactions(rocksdb_options_t* opt,
-                                                  int disable) {
-  opt->rep.disable_auto_compactions = disable;
-}
-
-void rocksdb_options_set_optimize_filters_for_hits(rocksdb_options_t* opt,
-                                                   int v) {
-  opt->rep.optimize_filters_for_hits = v;
-}
-
-void rocksdb_options_set_report_bg_io_stats(rocksdb_options_t* opt, int v) {
-  opt->rep.report_bg_io_stats = v;
-}
@@ -1,67 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/generate_c_api.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Source: tools/c_api_gen/spec.json
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/generate_c_api.py
-//     --spec tools/c_api_gen/spec.json --section 'Options simple'
-//     --header-out
-//     c_api_gen/c_generated_options_subset.h.inc
-//     --source-out
-//     c_api_gen/c_generated_options_subset.cc.inc
-
-/* Options simple */
-
-extern ROCKSDB_LIBRARY_API void
-rocksdb_options_set_compression_options_zstd_max_train_bytes(
-    rocksdb_options_t* opt, int zstd_max_train_bytes);
-
-extern ROCKSDB_LIBRARY_API int
-rocksdb_options_get_compression_options_zstd_max_train_bytes(
-    rocksdb_options_t* opt);
-
-extern ROCKSDB_LIBRARY_API void
-rocksdb_options_set_compression_options_use_zstd_dict_trainer(
-    rocksdb_options_t* opt, unsigned char use_zstd_dict_trainer);
-
-extern ROCKSDB_LIBRARY_API unsigned char
-rocksdb_options_get_compression_options_use_zstd_dict_trainer(
-    rocksdb_options_t* opt);
-
-extern ROCKSDB_LIBRARY_API void
-rocksdb_options_set_compression_options_parallel_threads(rocksdb_options_t* opt,
-                                                         int value);
-
-extern ROCKSDB_LIBRARY_API int
-rocksdb_options_get_compression_options_parallel_threads(
-    rocksdb_options_t* opt);
-
-extern ROCKSDB_LIBRARY_API void
-rocksdb_options_set_compression_options_max_dict_buffer_bytes(
-    rocksdb_options_t* opt, uint64_t max_dict_buffer_bytes);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_options_get_compression_options_max_dict_buffer_bytes(
-    rocksdb_options_t* opt);
-
-extern ROCKSDB_LIBRARY_API unsigned char
-rocksdb_options_get_bottommost_compression_options_use_zstd_dict_trainer(
-    rocksdb_options_t* opt);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_options_set_use_fsync(
-    rocksdb_options_t* opt, int use_fsync);
-
-extern ROCKSDB_LIBRARY_API int rocksdb_options_get_use_fsync(
-    rocksdb_options_t* opt);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_options_set_disable_auto_compactions(
-    rocksdb_options_t* opt, int disable);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_options_set_optimize_filters_for_hits(
-    rocksdb_options_t* opt, int v);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_options_set_report_bg_io_stats(
-    rocksdb_options_t* opt, int v);
@@ -1,236 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/auto_simple_bindings.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Sources:
-//   - include/rocksdb/options.h
-//   - tools/c_api_gen/auto_simple_bindings_blocklist.json
-//   - include/rocksdb/c.h
-//   - tools/c_api_gen/c_base.cc
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/auto_simple_bindings.py
-
-// Output group: Auto-discovered ReadOptions simple
-
-/* ReadOptions */
-
-void rocksdb_readoptions_set_deadline(rocksdb_readoptions_t* opt,
-                                      uint64_t microseconds) {
-  opt->rep.deadline = std::chrono::microseconds(microseconds);
-}
-
-uint64_t rocksdb_readoptions_get_deadline(rocksdb_readoptions_t* opt) {
-  return opt->rep.deadline.count();
-}
-
-void rocksdb_readoptions_set_io_timeout(rocksdb_readoptions_t* opt,
-                                        uint64_t microseconds) {
-  opt->rep.io_timeout = std::chrono::microseconds(microseconds);
-}
-
-uint64_t rocksdb_readoptions_get_io_timeout(rocksdb_readoptions_t* opt) {
-  return opt->rep.io_timeout.count();
-}
-
-void rocksdb_readoptions_set_read_tier(rocksdb_readoptions_t* opt, int v) {
-  opt->rep.read_tier = static_cast<decltype(opt->rep.read_tier)>(v);
-}
-
-int rocksdb_readoptions_get_read_tier(rocksdb_readoptions_t* opt) {
-  return static_cast<int>(opt->rep.read_tier);
-}
-
-void rocksdb_readoptions_set_rate_limiter_priority(rocksdb_readoptions_t* opt,
-                                                   int v) {
-  opt->rep.rate_limiter_priority =
-      static_cast<decltype(opt->rep.rate_limiter_priority)>(v);
-}
-
-int rocksdb_readoptions_get_rate_limiter_priority(rocksdb_readoptions_t* opt) {
-  return static_cast<int>(opt->rep.rate_limiter_priority);
-}
-
-void rocksdb_readoptions_set_value_size_soft_limit(rocksdb_readoptions_t* opt,
-                                                   uint64_t v) {
-  opt->rep.value_size_soft_limit = v;
-}
-
-uint64_t rocksdb_readoptions_get_value_size_soft_limit(
-    rocksdb_readoptions_t* opt) {
-  return opt->rep.value_size_soft_limit;
-}
-
-void rocksdb_readoptions_set_verify_checksums(rocksdb_readoptions_t* opt,
-                                              unsigned char v) {
-  opt->rep.verify_checksums = v;
-}
-
-unsigned char rocksdb_readoptions_get_verify_checksums(
-    rocksdb_readoptions_t* opt) {
-  return opt->rep.verify_checksums;
-}
-
-void rocksdb_readoptions_set_fill_cache(rocksdb_readoptions_t* opt,
-                                        unsigned char v) {
-  opt->rep.fill_cache = v;
-}
-
-unsigned char rocksdb_readoptions_get_fill_cache(rocksdb_readoptions_t* opt) {
-  return opt->rep.fill_cache;
-}
-
-void rocksdb_readoptions_set_ignore_range_deletions(rocksdb_readoptions_t* opt,
-                                                    unsigned char v) {
-  opt->rep.ignore_range_deletions = v;
-}
-
-unsigned char rocksdb_readoptions_get_ignore_range_deletions(
-    rocksdb_readoptions_t* opt) {
-  return opt->rep.ignore_range_deletions;
-}
-
-void rocksdb_readoptions_set_async_io(rocksdb_readoptions_t* opt,
-                                      unsigned char v) {
-  opt->rep.async_io = v;
-}
-
-unsigned char rocksdb_readoptions_get_async_io(rocksdb_readoptions_t* opt) {
-  return opt->rep.async_io;
-}
-
-void rocksdb_readoptions_set_optimize_multiget_for_io(
-    rocksdb_readoptions_t* opt, unsigned char v) {
-  opt->rep.optimize_multiget_for_io = v;
-}
-
-unsigned char rocksdb_readoptions_get_optimize_multiget_for_io(
-    rocksdb_readoptions_t* opt) {
-  return opt->rep.optimize_multiget_for_io;
-}
-
-void rocksdb_readoptions_set_readahead_size(rocksdb_readoptions_t* opt,
-                                            size_t v) {
-  opt->rep.readahead_size = v;
-}
-
-size_t rocksdb_readoptions_get_readahead_size(rocksdb_readoptions_t* opt) {
-  return opt->rep.readahead_size;
-}
-
-void rocksdb_readoptions_set_max_skippable_internal_keys(
-    rocksdb_readoptions_t* opt, uint64_t v) {
-  opt->rep.max_skippable_internal_keys = v;
-}
-
-uint64_t rocksdb_readoptions_get_max_skippable_internal_keys(
-    rocksdb_readoptions_t* opt) {
-  return opt->rep.max_skippable_internal_keys;
-}
-
-void rocksdb_readoptions_set_tailing(rocksdb_readoptions_t* opt,
-                                     unsigned char v) {
-  opt->rep.tailing = v;
-}
-
-unsigned char rocksdb_readoptions_get_tailing(rocksdb_readoptions_t* opt) {
-  return opt->rep.tailing;
-}
-
-void rocksdb_readoptions_set_total_order_seek(rocksdb_readoptions_t* opt,
-                                              unsigned char v) {
-  opt->rep.total_order_seek = v;
-}
-
-unsigned char rocksdb_readoptions_get_total_order_seek(
-    rocksdb_readoptions_t* opt) {
-  return opt->rep.total_order_seek;
-}
-
-void rocksdb_readoptions_set_auto_prefix_mode(rocksdb_readoptions_t* opt,
-                                              unsigned char v) {
-  opt->rep.auto_prefix_mode = v;
-}
-
-unsigned char rocksdb_readoptions_get_auto_prefix_mode(
-    rocksdb_readoptions_t* opt) {
-  return opt->rep.auto_prefix_mode;
-}
-
-void rocksdb_readoptions_set_prefix_same_as_start(rocksdb_readoptions_t* opt,
-                                                  unsigned char v) {
-  opt->rep.prefix_same_as_start = v;
-}
-
-unsigned char rocksdb_readoptions_get_prefix_same_as_start(
-    rocksdb_readoptions_t* opt) {
-  return opt->rep.prefix_same_as_start;
-}
-
-void rocksdb_readoptions_set_pin_data(rocksdb_readoptions_t* opt,
-                                      unsigned char v) {
-  opt->rep.pin_data = v;
-}
-
-unsigned char rocksdb_readoptions_get_pin_data(rocksdb_readoptions_t* opt) {
-  return opt->rep.pin_data;
-}
-
-void rocksdb_readoptions_set_adaptive_readahead(rocksdb_readoptions_t* opt,
-                                                unsigned char v) {
-  opt->rep.adaptive_readahead = v;
-}
-
-unsigned char rocksdb_readoptions_get_adaptive_readahead(
-    rocksdb_readoptions_t* opt) {
-  return opt->rep.adaptive_readahead;
-}
-
-void rocksdb_readoptions_set_background_purge_on_iterator_cleanup(
-    rocksdb_readoptions_t* opt, unsigned char v) {
-  opt->rep.background_purge_on_iterator_cleanup = v;
-}
-
-unsigned char rocksdb_readoptions_get_background_purge_on_iterator_cleanup(
-    rocksdb_readoptions_t* opt) {
-  return opt->rep.background_purge_on_iterator_cleanup;
-}
-
-void rocksdb_readoptions_set_auto_readahead_size(rocksdb_readoptions_t* opt,
-                                                 unsigned char v) {
-  opt->rep.auto_readahead_size = v;
-}
-
-unsigned char rocksdb_readoptions_get_auto_readahead_size(
-    rocksdb_readoptions_t* opt) {
-  return opt->rep.auto_readahead_size;
-}
-
-void rocksdb_readoptions_set_allow_unprepared_value(rocksdb_readoptions_t* opt,
-                                                    unsigned char v) {
-  opt->rep.allow_unprepared_value = v;
-}
-
-unsigned char rocksdb_readoptions_get_allow_unprepared_value(
-    rocksdb_readoptions_t* opt) {
-  return opt->rep.allow_unprepared_value;
-}
-
-void rocksdb_readoptions_set_auto_refresh_iterator_with_snapshot(
-    rocksdb_readoptions_t* opt, unsigned char v) {
-  opt->rep.auto_refresh_iterator_with_snapshot = v;
-}
-
-unsigned char rocksdb_readoptions_get_auto_refresh_iterator_with_snapshot(
-    rocksdb_readoptions_t* opt) {
-  return opt->rep.auto_refresh_iterator_with_snapshot;
-}
-
-void rocksdb_readoptions_set_io_activity(rocksdb_readoptions_t* opt, int v) {
-  opt->rep.io_activity = static_cast<decltype(opt->rep.io_activity)>(v);
-}
-
-int rocksdb_readoptions_get_io_activity(rocksdb_readoptions_t* opt) {
-  return static_cast<int>(opt->rep.io_activity);
-}
@@ -1,161 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/auto_simple_bindings.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Sources:
-//   - include/rocksdb/options.h
-//   - tools/c_api_gen/auto_simple_bindings_blocklist.json
-//   - include/rocksdb/c.h
-//   - tools/c_api_gen/c_base.cc
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/auto_simple_bindings.py
-
-// Output group: Auto-discovered ReadOptions simple
-
-/* ReadOptions */
-
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_deadline(
-    rocksdb_readoptions_t* opt, uint64_t microseconds);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_readoptions_get_deadline(rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_io_timeout(
-    rocksdb_readoptions_t* opt, uint64_t microseconds);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_readoptions_get_io_timeout(rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_read_tier(
-    rocksdb_readoptions_t* opt, int v);
-
-extern ROCKSDB_LIBRARY_API int rocksdb_readoptions_get_read_tier(
-    rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_rate_limiter_priority(
-    rocksdb_readoptions_t* opt, int v);
-
-extern ROCKSDB_LIBRARY_API int rocksdb_readoptions_get_rate_limiter_priority(
-    rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_value_size_soft_limit(
-    rocksdb_readoptions_t* opt, uint64_t v);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_readoptions_get_value_size_soft_limit(rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_verify_checksums(
-    rocksdb_readoptions_t* opt, unsigned char v);
-
-extern ROCKSDB_LIBRARY_API unsigned char
-rocksdb_readoptions_get_verify_checksums(rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_fill_cache(
-    rocksdb_readoptions_t* opt, unsigned char v);
-
-extern ROCKSDB_LIBRARY_API unsigned char rocksdb_readoptions_get_fill_cache(
-    rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_ignore_range_deletions(
-    rocksdb_readoptions_t* opt, unsigned char v);
-
-extern ROCKSDB_LIBRARY_API unsigned char
-rocksdb_readoptions_get_ignore_range_deletions(rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_async_io(
-    rocksdb_readoptions_t* opt, unsigned char v);
-
-extern ROCKSDB_LIBRARY_API unsigned char rocksdb_readoptions_get_async_io(
-    rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void
-rocksdb_readoptions_set_optimize_multiget_for_io(rocksdb_readoptions_t* opt,
-                                                 unsigned char v);
-
-extern ROCKSDB_LIBRARY_API unsigned char
-rocksdb_readoptions_get_optimize_multiget_for_io(rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_readahead_size(
-    rocksdb_readoptions_t* opt, size_t v);
-
-extern ROCKSDB_LIBRARY_API size_t
-rocksdb_readoptions_get_readahead_size(rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void
-rocksdb_readoptions_set_max_skippable_internal_keys(rocksdb_readoptions_t* opt,
-                                                    uint64_t v);
-
-extern ROCKSDB_LIBRARY_API uint64_t
-rocksdb_readoptions_get_max_skippable_internal_keys(rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_tailing(
-    rocksdb_readoptions_t* opt, unsigned char v);
-
-extern ROCKSDB_LIBRARY_API unsigned char rocksdb_readoptions_get_tailing(
-    rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_total_order_seek(
-    rocksdb_readoptions_t* opt, unsigned char v);
-
-extern ROCKSDB_LIBRARY_API unsigned char
-rocksdb_readoptions_get_total_order_seek(rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_auto_prefix_mode(
-    rocksdb_readoptions_t* opt, unsigned char v);
-
-extern ROCKSDB_LIBRARY_API unsigned char
-rocksdb_readoptions_get_auto_prefix_mode(rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_prefix_same_as_start(
-    rocksdb_readoptions_t* opt, unsigned char v);
-
-extern ROCKSDB_LIBRARY_API unsigned char
-rocksdb_readoptions_get_prefix_same_as_start(rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_pin_data(
-    rocksdb_readoptions_t* opt, unsigned char v);
-
-extern ROCKSDB_LIBRARY_API unsigned char rocksdb_readoptions_get_pin_data(
-    rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_adaptive_readahead(
-    rocksdb_readoptions_t* opt, unsigned char v);
-
-extern ROCKSDB_LIBRARY_API unsigned char
-rocksdb_readoptions_get_adaptive_readahead(rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void
-rocksdb_readoptions_set_background_purge_on_iterator_cleanup(
-    rocksdb_readoptions_t* opt, unsigned char v);
-
-extern ROCKSDB_LIBRARY_API unsigned char
-rocksdb_readoptions_get_background_purge_on_iterator_cleanup(
-    rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_auto_readahead_size(
-    rocksdb_readoptions_t* opt, unsigned char v);
-
-extern ROCKSDB_LIBRARY_API unsigned char
-rocksdb_readoptions_get_auto_readahead_size(rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_allow_unprepared_value(
-    rocksdb_readoptions_t* opt, unsigned char v);
-
-extern ROCKSDB_LIBRARY_API unsigned char
-rocksdb_readoptions_get_allow_unprepared_value(rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void
-rocksdb_readoptions_set_auto_refresh_iterator_with_snapshot(
-    rocksdb_readoptions_t* opt, unsigned char v);
-
-extern ROCKSDB_LIBRARY_API unsigned char
-rocksdb_readoptions_get_auto_refresh_iterator_with_snapshot(
-    rocksdb_readoptions_t* opt);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_io_activity(
-    rocksdb_readoptions_t* opt, int v);
-
-extern ROCKSDB_LIBRARY_API int rocksdb_readoptions_get_io_activity(
-    rocksdb_readoptions_t* opt);
@@ -1,371 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/generate_c_api.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Source: tools/c_api_gen/spec.json
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/generate_c_api.py
-//     --spec tools/c_api_gen/spec.json --section 'DB data operations'
-//     --section 'WriteBatch' --section 'Transaction'
-//     --section 'TransactionDB simple'
-//     --header-out
-//     c_api_gen/c_generated_subset.h.inc
-//     --source-out
-//     c_api_gen/c_generated_subset.cc.inc
-
-/* DB data operations */
-
-void rocksdb_put(rocksdb_t* db, const rocksdb_writeoptions_t* options,
-                 const char* key, size_t keylen, const char* val, size_t vallen,
-                 char** errptr) {
-  SaveError(errptr,
-            db->rep->Put(options->rep, Slice(key, keylen), Slice(val, vallen)));
-}
-
-void rocksdb_put_cf(rocksdb_t* db, const rocksdb_writeoptions_t* options,
-                    rocksdb_column_family_handle_t* column_family,
-                    const char* key, size_t keylen, const char* val,
-                    size_t vallen, char** errptr) {
-  SaveError(errptr, db->rep->Put(options->rep, column_family->rep,
-                                 Slice(key, keylen), Slice(val, vallen)));
-}
-
-void rocksdb_delete(rocksdb_t* db, const rocksdb_writeoptions_t* options,
-                    const char* key, size_t keylen, char** errptr) {
-  SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen)));
-}
-
-void rocksdb_delete_cf(rocksdb_t* db, const rocksdb_writeoptions_t* options,
-                       rocksdb_column_family_handle_t* column_family,
-                       const char* key, size_t keylen, char** errptr) {
-  SaveError(errptr, db->rep->Delete(options->rep, column_family->rep,
-                                    Slice(key, keylen)));
-}
-
-void rocksdb_merge(rocksdb_t* db, const rocksdb_writeoptions_t* options,
-                   const char* key, size_t keylen, const char* val,
-                   size_t vallen, char** errptr) {
-  SaveError(errptr, db->rep->Merge(options->rep, Slice(key, keylen),
-                                   Slice(val, vallen)));
-}
-
-void rocksdb_merge_cf(rocksdb_t* db, const rocksdb_writeoptions_t* options,
-                      rocksdb_column_family_handle_t* column_family,
-                      const char* key, size_t keylen, const char* val,
-                      size_t vallen, char** errptr) {
-  SaveError(errptr, db->rep->Merge(options->rep, column_family->rep,
-                                   Slice(key, keylen), Slice(val, vallen)));
-}
-
-void rocksdb_write(rocksdb_t* db, const rocksdb_writeoptions_t* options,
-                   rocksdb_writebatch_t* batch, char** errptr) {
-  SaveError(errptr, db->rep->Write(options->rep, &batch->rep));
-}
-
-void rocksdb_put_with_ts(rocksdb_t* db, const rocksdb_writeoptions_t* options,
-                         const char* key, size_t keylen, const char* ts,
-                         size_t tslen, const char* val, size_t vallen,
-                         char** errptr) {
-  SaveError(errptr, db->rep->Put(options->rep, Slice(key, keylen),
-                                 Slice(ts, tslen), Slice(val, vallen)));
-}
-
-void rocksdb_put_cf_with_ts(rocksdb_t* db,
-                            const rocksdb_writeoptions_t* options,
-                            rocksdb_column_family_handle_t* column_family,
-                            const char* key, size_t keylen, const char* ts,
-                            size_t tslen, const char* val, size_t vallen,
-                            char** errptr) {
-  SaveError(errptr,
-            db->rep->Put(options->rep, column_family->rep, Slice(key, keylen),
-                         Slice(ts, tslen), Slice(val, vallen)));
-}
-
-void rocksdb_delete_with_ts(rocksdb_t* db,
-                            const rocksdb_writeoptions_t* options,
-                            const char* key, size_t keylen, const char* ts,
-                            size_t tslen, char** errptr) {
-  SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen),
-                                    Slice(ts, tslen)));
-}
-
-void rocksdb_delete_cf_with_ts(rocksdb_t* db,
-                               const rocksdb_writeoptions_t* options,
-                               rocksdb_column_family_handle_t* column_family,
-                               const char* key, size_t keylen, const char* ts,
-                               size_t tslen, char** errptr) {
-  SaveError(errptr, db->rep->Delete(options->rep, column_family->rep,
-                                    Slice(key, keylen), Slice(ts, tslen)));
-}
-
-void rocksdb_singledelete(rocksdb_t* db, const rocksdb_writeoptions_t* options,
-                          const char* key, size_t keylen, char** errptr) {
-  SaveError(errptr, db->rep->SingleDelete(options->rep, Slice(key, keylen)));
-}
-
-void rocksdb_singledelete_cf(rocksdb_t* db,
-                             const rocksdb_writeoptions_t* options,
-                             rocksdb_column_family_handle_t* column_family,
-                             const char* key, size_t keylen, char** errptr) {
-  SaveError(errptr, db->rep->SingleDelete(options->rep, column_family->rep,
-                                          Slice(key, keylen)));
-}
-
-void rocksdb_singledelete_with_ts(rocksdb_t* db,
-                                  const rocksdb_writeoptions_t* options,
-                                  const char* key, size_t keylen,
-                                  const char* ts, size_t tslen, char** errptr) {
-  SaveError(errptr, db->rep->SingleDelete(options->rep, Slice(key, keylen),
-                                          Slice(ts, tslen)));
-}
-
-void rocksdb_singledelete_cf_with_ts(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, const char* ts, size_t tslen, char** errptr) {
-  SaveError(errptr,
-            db->rep->SingleDelete(options->rep, column_family->rep,
-                                  Slice(key, keylen), Slice(ts, tslen)));
-}
-
-void rocksdb_delete_range_cf(rocksdb_t* db,
-                             const rocksdb_writeoptions_t* options,
-                             rocksdb_column_family_handle_t* column_family,
-                             const char* start_key, size_t start_key_len,
-                             const char* end_key, size_t end_key_len,
-                             char** errptr) {
-  SaveError(errptr, db->rep->DeleteRange(options->rep, column_family->rep,
-                                         Slice(start_key, start_key_len),
-                                         Slice(end_key, end_key_len)));
-}
-
-void rocksdb_flush(rocksdb_t* db, const rocksdb_flushoptions_t* options,
-                   char** errptr) {
-  SaveError(errptr, db->rep->Flush(options->rep));
-}
-
-void rocksdb_flush_cf(rocksdb_t* db, const rocksdb_flushoptions_t* options,
-                      rocksdb_column_family_handle_t* column_family,
-                      char** errptr) {
-  SaveError(errptr, db->rep->Flush(options->rep, column_family->rep));
-}
-
-void rocksdb_flush_wal(rocksdb_t* db, unsigned char sync, char** errptr) {
-  SaveError(errptr, db->rep->FlushWAL(sync));
-}
-
-void rocksdb_pause_background_work(rocksdb_t* db, char** errptr) {
-  SaveError(errptr, db->rep->PauseBackgroundWork());
-}
-
-void rocksdb_continue_background_work(rocksdb_t* db, char** errptr) {
-  SaveError(errptr, db->rep->ContinueBackgroundWork());
-}
-
-void rocksdb_disable_file_deletions(rocksdb_t* db, char** errptr) {
-  SaveError(errptr, db->rep->DisableFileDeletions());
-}
-
-void rocksdb_enable_file_deletions(rocksdb_t* db, char** errptr) {
-  SaveError(errptr, db->rep->EnableFileDeletions());
-}
-
-void rocksdb_verify_checksum(rocksdb_t* db, char** errptr) {
-  SaveError(errptr, db->rep->VerifyChecksum());
-}
-
-void rocksdb_verify_file_checksums(rocksdb_t* db, char** errptr) {
-  SaveError(errptr, db->rep->VerifyFileChecksums(ReadOptions()));
-}
-
-void rocksdb_destroy_db(const rocksdb_options_t* options, const char* name,
-                        char** errptr) {
-  SaveError(errptr, DestroyDB(name, options->rep));
-}
-
-void rocksdb_repair_db(const rocksdb_options_t* options, const char* name,
-                       char** errptr) {
-  SaveError(errptr, RepairDB(name, options->rep));
-}
-
-/* WriteBatch */
-
-void rocksdb_writebatch_clear(rocksdb_writebatch_t* b) { b->rep.Clear(); }
-
-void rocksdb_writebatch_put(rocksdb_writebatch_t* b, const char* key,
-                            size_t klen, const char* val, size_t vlen) {
-  b->rep.Put(Slice(key, klen), Slice(val, vlen));
-}
-
-void rocksdb_writebatch_put_cf(rocksdb_writebatch_t* b,
-                               rocksdb_column_family_handle_t* column_family,
-                               const char* key, size_t klen, const char* val,
-                               size_t vlen) {
-  b->rep.Put(column_family->rep, Slice(key, klen), Slice(val, vlen));
-}
-
-void rocksdb_writebatch_delete(rocksdb_writebatch_t* b, const char* key,
-                               size_t klen) {
-  b->rep.Delete(Slice(key, klen));
-}
-
-void rocksdb_writebatch_put_log_data(rocksdb_writebatch_t* b, const char* blob,
-                                     size_t len) {
-  b->rep.PutLogData(Slice(blob, len));
-}
-
-void rocksdb_writebatch_set_save_point(rocksdb_writebatch_t* b) {
-  b->rep.SetSavePoint();
-}
-
-void rocksdb_writebatch_rollback_to_save_point(rocksdb_writebatch_t* b,
-                                               char** errptr) {
-  SaveError(errptr, b->rep.RollbackToSavePoint());
-}
-
-void rocksdb_writebatch_pop_save_point(rocksdb_writebatch_t* b, char** errptr) {
-  SaveError(errptr, b->rep.PopSavePoint());
-}
-
-void rocksdb_writebatch_verify_checksum(rocksdb_writebatch_t* b,
-                                        char** errptr) {
-  SaveError(errptr, b->rep.VerifyChecksum());
-}
-
-/* Transaction */
-
-void rocksdb_transaction_put(rocksdb_transaction_t* txn, const char* key,
-                             size_t klen, const char* val, size_t vlen,
-                             char** errptr) {
-  SaveError(errptr, txn->rep->Put(Slice(key, klen), Slice(val, vlen)));
-}
-
-void rocksdb_transaction_put_cf(rocksdb_transaction_t* txn,
-                                rocksdb_column_family_handle_t* column_family,
-                                const char* key, size_t klen, const char* val,
-                                size_t vlen, char** errptr) {
-  SaveError(errptr, txn->rep->Put(column_family->rep, Slice(key, klen),
-                                  Slice(val, vlen)));
-}
-
-void rocksdb_transaction_merge(rocksdb_transaction_t* txn, const char* key,
-                               size_t klen, const char* val, size_t vlen,
-                               char** errptr) {
-  SaveError(errptr, txn->rep->Merge(Slice(key, klen), Slice(val, vlen)));
-}
-
-void rocksdb_transaction_merge_cf(rocksdb_transaction_t* txn,
-                                  rocksdb_column_family_handle_t* column_family,
-                                  const char* key, size_t klen, const char* val,
-                                  size_t vlen, char** errptr) {
-  SaveError(errptr, txn->rep->Merge(column_family->rep, Slice(key, klen),
-                                    Slice(val, vlen)));
-}
-
-void rocksdb_transaction_delete(rocksdb_transaction_t* txn, const char* key,
-                                size_t klen, char** errptr) {
-  SaveError(errptr, txn->rep->Delete(Slice(key, klen)));
-}
-
-void rocksdb_transaction_delete_cf(
-    rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family,
-    const char* key, size_t klen, char** errptr) {
-  SaveError(errptr, txn->rep->Delete(column_family->rep, Slice(key, klen)));
-}
-
-void rocksdb_transaction_commit(rocksdb_transaction_t* txn, char** errptr) {
-  SaveError(errptr, txn->rep->Commit());
-}
-
-void rocksdb_transaction_rollback(rocksdb_transaction_t* txn, char** errptr) {
-  SaveError(errptr, txn->rep->Rollback());
-}
-
-void rocksdb_transaction_put_log_data(rocksdb_transaction_t* txn,
-                                      const char* blob, size_t len) {
-  txn->rep->PutLogData(Slice(blob, len));
-}
-
-void rocksdb_transaction_set_savepoint(rocksdb_transaction_t* txn) {
-  txn->rep->SetSavePoint();
-}
-
-void rocksdb_transaction_rollback_to_savepoint(rocksdb_transaction_t* txn,
-                                               char** errptr) {
-  SaveError(errptr, txn->rep->RollbackToSavePoint());
-}
-
-/* TransactionDB simple */
-
-void rocksdb_transactiondb_put(rocksdb_transactiondb_t* txn_db,
-                               const rocksdb_writeoptions_t* options,
-                               const char* key, size_t klen, const char* val,
-                               size_t vlen, char** errptr) {
-  SaveError(errptr,
-            txn_db->rep->Put(options->rep, Slice(key, klen), Slice(val, vlen)));
-}
-
-void rocksdb_transactiondb_put_cf(rocksdb_transactiondb_t* txn_db,
-                                  const rocksdb_writeoptions_t* options,
-                                  rocksdb_column_family_handle_t* column_family,
-                                  const char* key, size_t keylen,
-                                  const char* val, size_t vallen,
-                                  char** errptr) {
-  SaveError(errptr, txn_db->rep->Put(options->rep, column_family->rep,
-                                     Slice(key, keylen), Slice(val, vallen)));
-}
-
-void rocksdb_transactiondb_write(rocksdb_transactiondb_t* db,
-                                 const rocksdb_writeoptions_t* options,
-                                 rocksdb_writebatch_t* batch, char** errptr) {
-  SaveError(errptr, db->rep->Write(options->rep, &batch->rep));
-}
-
-void rocksdb_transactiondb_merge(rocksdb_transactiondb_t* txn_db,
-                                 const rocksdb_writeoptions_t* options,
-                                 const char* key, size_t klen, const char* val,
-                                 size_t vlen, char** errptr) {
-  SaveError(errptr, txn_db->rep->Merge(options->rep, Slice(key, klen),
-                                       Slice(val, vlen)));
-}
-
-void rocksdb_transactiondb_merge_cf(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key, size_t klen,
-    const char* val, size_t vlen, char** errptr) {
-  SaveError(errptr, txn_db->rep->Merge(options->rep, column_family->rep,
-                                       Slice(key, klen), Slice(val, vlen)));
-}
-
-void rocksdb_transactiondb_delete(rocksdb_transactiondb_t* txn_db,
-                                  const rocksdb_writeoptions_t* options,
-                                  const char* key, size_t klen, char** errptr) {
-  SaveError(errptr, txn_db->rep->Delete(options->rep, Slice(key, klen)));
-}
-
-void rocksdb_transactiondb_delete_cf(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, char** errptr) {
-  SaveError(errptr, txn_db->rep->Delete(options->rep, column_family->rep,
-                                        Slice(key, keylen)));
-}
-
-void rocksdb_transactiondb_flush_wal(rocksdb_transactiondb_t* txn_db,
-                                     unsigned char sync, char** errptr) {
-  SaveError(errptr, txn_db->rep->FlushWAL(sync));
-}
-
-void rocksdb_transactiondb_flush(rocksdb_transactiondb_t* txn_db,
-                                 const rocksdb_flushoptions_t* options,
-                                 char** errptr) {
-  SaveError(errptr, txn_db->rep->Flush(options->rep));
-}
-
-void rocksdb_transactiondb_flush_cf(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, char** errptr) {
-  SaveError(errptr, txn_db->rep->Flush(options->rep, column_family->rep));
-}
@@ -1,245 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/generate_c_api.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Source: tools/c_api_gen/spec.json
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/generate_c_api.py
-//     --spec tools/c_api_gen/spec.json --section 'DB data operations'
-//     --section 'WriteBatch' --section 'Transaction'
-//     --section 'TransactionDB simple'
-//     --header-out
-//     c_api_gen/c_generated_subset.h.inc
-//     --source-out
-//     c_api_gen/c_generated_subset.cc.inc
-
-/* DB data operations */
-
-extern ROCKSDB_LIBRARY_API void rocksdb_put(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key,
-    size_t keylen, const char* val, size_t vallen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_put_cf(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, const char* val, size_t vallen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_delete(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key,
-    size_t keylen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_delete_cf(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_merge(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key,
-    size_t keylen, const char* val, size_t vallen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_merge_cf(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, const char* val, size_t vallen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_write(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_writebatch_t* batch, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_put_with_ts(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key,
-    size_t keylen, const char* ts, size_t tslen, const char* val, size_t vallen,
-    char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_put_cf_with_ts(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, const char* ts, size_t tslen, const char* val, size_t vallen,
-    char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_delete_with_ts(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key,
-    size_t keylen, const char* ts, size_t tslen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_delete_cf_with_ts(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, const char* ts, size_t tslen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_singledelete(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key,
-    size_t keylen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_singledelete_cf(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_singledelete_with_ts(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key,
-    size_t keylen, const char* ts, size_t tslen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_singledelete_cf_with_ts(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, const char* ts, size_t tslen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_delete_range_cf(
-    rocksdb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* start_key,
-    size_t start_key_len, const char* end_key, size_t end_key_len,
-    char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_flush(
-    rocksdb_t* db, const rocksdb_flushoptions_t* options, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_flush_cf(
-    rocksdb_t* db, const rocksdb_flushoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_flush_wal(rocksdb_t* db,
-                                                  unsigned char sync,
-                                                  char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_pause_background_work(rocksdb_t* db,
-                                                              char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_continue_background_work(rocksdb_t* db,
-                                                                 char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_disable_file_deletions(rocksdb_t* db,
-                                                               char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_enable_file_deletions(rocksdb_t* db,
-                                                              char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_verify_checksum(rocksdb_t* db,
-                                                        char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_verify_file_checksums(rocksdb_t* db,
-                                                              char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_destroy_db(
-    const rocksdb_options_t* options, const char* name, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_repair_db(
-    const rocksdb_options_t* options, const char* name, char** errptr);
-
-/* WriteBatch */
-
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_clear(
-    rocksdb_writebatch_t* b);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_put(rocksdb_writebatch_t* b,
-                                                       const char* key,
-                                                       size_t klen,
-                                                       const char* val,
-                                                       size_t vlen);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_put_cf(
-    rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family,
-    const char* key, size_t klen, const char* val, size_t vlen);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_delete(
-    rocksdb_writebatch_t* b, const char* key, size_t klen);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_put_log_data(
-    rocksdb_writebatch_t* b, const char* blob, size_t len);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_set_save_point(
-    rocksdb_writebatch_t* b);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_rollback_to_save_point(
-    rocksdb_writebatch_t* b, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_pop_save_point(
-    rocksdb_writebatch_t* b, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_verify_checksum(
-    rocksdb_writebatch_t* b, char** errptr);
-
-/* Transaction */
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_put(
-    rocksdb_transaction_t* txn, const char* key, size_t klen, const char* val,
-    size_t vlen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_put_cf(
-    rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family,
-    const char* key, size_t klen, const char* val, size_t vlen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_merge(
-    rocksdb_transaction_t* txn, const char* key, size_t klen, const char* val,
-    size_t vlen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_merge_cf(
-    rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family,
-    const char* key, size_t klen, const char* val, size_t vlen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_delete(
-    rocksdb_transaction_t* txn, const char* key, size_t klen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_delete_cf(
-    rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family,
-    const char* key, size_t klen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_commit(
-    rocksdb_transaction_t* txn, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_rollback(
-    rocksdb_transaction_t* txn, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_put_log_data(
-    rocksdb_transaction_t* txn, const char* blob, size_t len);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_set_savepoint(
-    rocksdb_transaction_t* txn);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_rollback_to_savepoint(
-    rocksdb_transaction_t* txn, char** errptr);
-
-/* TransactionDB simple */
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_put(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
-    const char* key, size_t klen, const char* val, size_t vlen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_put_cf(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, const char* val, size_t vallen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_write(
-    rocksdb_transactiondb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_writebatch_t* batch, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_merge(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
-    const char* key, size_t klen, const char* val, size_t vlen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_merge_cf(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key, size_t klen,
-    const char* val, size_t vlen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_delete(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
-    const char* key, size_t klen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_delete_cf(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush_wal(
-    rocksdb_transactiondb_t* txn_db, unsigned char sync, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options,
-    char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush_cf(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, char** errptr);
@@ -1,77 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/generate_c_api.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Source: tools/c_api_gen/spec.json
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/generate_c_api.py
-//     --spec tools/c_api_gen/spec.json --section 'Transaction'
-//     --header-out
-//     c_api_gen/c_generated_transaction_subset.h.inc
-//     --source-out
-//     c_api_gen/c_generated_transaction_subset.cc.inc
-
-/* Transaction */
-
-void rocksdb_transaction_put(rocksdb_transaction_t* txn, const char* key,
-                             size_t klen, const char* val, size_t vlen,
-                             char** errptr) {
-  SaveError(errptr, txn->rep->Put(Slice(key, klen), Slice(val, vlen)));
-}
-
-void rocksdb_transaction_put_cf(rocksdb_transaction_t* txn,
-                                rocksdb_column_family_handle_t* column_family,
-                                const char* key, size_t klen, const char* val,
-                                size_t vlen, char** errptr) {
-  SaveError(errptr, txn->rep->Put(column_family->rep, Slice(key, klen),
-                                  Slice(val, vlen)));
-}
-
-void rocksdb_transaction_merge(rocksdb_transaction_t* txn, const char* key,
-                               size_t klen, const char* val, size_t vlen,
-                               char** errptr) {
-  SaveError(errptr, txn->rep->Merge(Slice(key, klen), Slice(val, vlen)));
-}
-
-void rocksdb_transaction_merge_cf(rocksdb_transaction_t* txn,
-                                  rocksdb_column_family_handle_t* column_family,
-                                  const char* key, size_t klen, const char* val,
-                                  size_t vlen, char** errptr) {
-  SaveError(errptr, txn->rep->Merge(column_family->rep, Slice(key, klen),
-                                    Slice(val, vlen)));
-}
-
-void rocksdb_transaction_delete(rocksdb_transaction_t* txn, const char* key,
-                                size_t klen, char** errptr) {
-  SaveError(errptr, txn->rep->Delete(Slice(key, klen)));
-}
-
-void rocksdb_transaction_delete_cf(
-    rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family,
-    const char* key, size_t klen, char** errptr) {
-  SaveError(errptr, txn->rep->Delete(column_family->rep, Slice(key, klen)));
-}
-
-void rocksdb_transaction_commit(rocksdb_transaction_t* txn, char** errptr) {
-  SaveError(errptr, txn->rep->Commit());
-}
-
-void rocksdb_transaction_rollback(rocksdb_transaction_t* txn, char** errptr) {
-  SaveError(errptr, txn->rep->Rollback());
-}
-
-void rocksdb_transaction_put_log_data(rocksdb_transaction_t* txn,
-                                      const char* blob, size_t len) {
-  txn->rep->PutLogData(Slice(blob, len));
-}
-
-void rocksdb_transaction_set_savepoint(rocksdb_transaction_t* txn) {
-  txn->rep->SetSavePoint();
-}
-
-void rocksdb_transaction_rollback_to_savepoint(rocksdb_transaction_t* txn,
-                                               char** errptr) {
-  SaveError(errptr, txn->rep->RollbackToSavePoint());
-}
@@ -1,54 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/generate_c_api.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Source: tools/c_api_gen/spec.json
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/generate_c_api.py
-//     --spec tools/c_api_gen/spec.json --section 'Transaction'
-//     --header-out
-//     c_api_gen/c_generated_transaction_subset.h.inc
-//     --source-out
-//     c_api_gen/c_generated_transaction_subset.cc.inc
-
-/* Transaction */
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_put(
-    rocksdb_transaction_t* txn, const char* key, size_t klen, const char* val,
-    size_t vlen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_put_cf(
-    rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family,
-    const char* key, size_t klen, const char* val, size_t vlen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_merge(
-    rocksdb_transaction_t* txn, const char* key, size_t klen, const char* val,
-    size_t vlen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_merge_cf(
-    rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family,
-    const char* key, size_t klen, const char* val, size_t vlen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_delete(
-    rocksdb_transaction_t* txn, const char* key, size_t klen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_delete_cf(
-    rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family,
-    const char* key, size_t klen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_commit(
-    rocksdb_transaction_t* txn, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_rollback(
-    rocksdb_transaction_t* txn, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_put_log_data(
-    rocksdb_transaction_t* txn, const char* blob, size_t len);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_set_savepoint(
-    rocksdb_transaction_t* txn);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transaction_rollback_to_savepoint(
-    rocksdb_transaction_t* txn, char** errptr);
@@ -1,87 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/generate_c_api.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Source: tools/c_api_gen/spec.json
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/generate_c_api.py
-//     --spec tools/c_api_gen/spec.json --section 'TransactionDB simple'
-//     --header-out
-//     c_api_gen/c_generated_transactiondb_subset.h.inc
-//     --source-out
-//     c_api_gen/c_generated_transactiondb_subset.cc.inc
-
-/* TransactionDB simple */
-
-void rocksdb_transactiondb_put(rocksdb_transactiondb_t* txn_db,
-                               const rocksdb_writeoptions_t* options,
-                               const char* key, size_t klen, const char* val,
-                               size_t vlen, char** errptr) {
-  SaveError(errptr,
-            txn_db->rep->Put(options->rep, Slice(key, klen), Slice(val, vlen)));
-}
-
-void rocksdb_transactiondb_put_cf(rocksdb_transactiondb_t* txn_db,
-                                  const rocksdb_writeoptions_t* options,
-                                  rocksdb_column_family_handle_t* column_family,
-                                  const char* key, size_t keylen,
-                                  const char* val, size_t vallen,
-                                  char** errptr) {
-  SaveError(errptr, txn_db->rep->Put(options->rep, column_family->rep,
-                                     Slice(key, keylen), Slice(val, vallen)));
-}
-
-void rocksdb_transactiondb_write(rocksdb_transactiondb_t* db,
-                                 const rocksdb_writeoptions_t* options,
-                                 rocksdb_writebatch_t* batch, char** errptr) {
-  SaveError(errptr, db->rep->Write(options->rep, &batch->rep));
-}
-
-void rocksdb_transactiondb_merge(rocksdb_transactiondb_t* txn_db,
-                                 const rocksdb_writeoptions_t* options,
-                                 const char* key, size_t klen, const char* val,
-                                 size_t vlen, char** errptr) {
-  SaveError(errptr, txn_db->rep->Merge(options->rep, Slice(key, klen),
-                                       Slice(val, vlen)));
-}
-
-void rocksdb_transactiondb_merge_cf(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key, size_t klen,
-    const char* val, size_t vlen, char** errptr) {
-  SaveError(errptr, txn_db->rep->Merge(options->rep, column_family->rep,
-                                       Slice(key, klen), Slice(val, vlen)));
-}
-
-void rocksdb_transactiondb_delete(rocksdb_transactiondb_t* txn_db,
-                                  const rocksdb_writeoptions_t* options,
-                                  const char* key, size_t klen, char** errptr) {
-  SaveError(errptr, txn_db->rep->Delete(options->rep, Slice(key, klen)));
-}
-
-void rocksdb_transactiondb_delete_cf(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, char** errptr) {
-  SaveError(errptr, txn_db->rep->Delete(options->rep, column_family->rep,
-                                        Slice(key, keylen)));
-}
-
-void rocksdb_transactiondb_flush_wal(rocksdb_transactiondb_t* txn_db,
-                                     unsigned char sync, char** errptr) {
-  SaveError(errptr, txn_db->rep->FlushWAL(sync));
-}
-
-void rocksdb_transactiondb_flush(rocksdb_transactiondb_t* txn_db,
-                                 const rocksdb_flushoptions_t* options,
-                                 char** errptr) {
-  SaveError(errptr, txn_db->rep->Flush(options->rep));
-}
-
-void rocksdb_transactiondb_flush_cf(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, char** errptr) {
-  SaveError(errptr, txn_db->rep->Flush(options->rep, column_family->rep));
-}
@@ -1,58 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/generate_c_api.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Source: tools/c_api_gen/spec.json
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/generate_c_api.py
-//     --spec tools/c_api_gen/spec.json --section 'TransactionDB simple'
-//     --header-out
-//     c_api_gen/c_generated_transactiondb_subset.h.inc
-//     --source-out
-//     c_api_gen/c_generated_transactiondb_subset.cc.inc
-
-/* TransactionDB simple */
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_put(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
-    const char* key, size_t klen, const char* val, size_t vlen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_put_cf(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, const char* val, size_t vallen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_write(
-    rocksdb_transactiondb_t* db, const rocksdb_writeoptions_t* options,
-    rocksdb_writebatch_t* batch, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_merge(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
-    const char* key, size_t klen, const char* val, size_t vlen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_merge_cf(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key, size_t klen,
-    const char* val, size_t vlen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_delete(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
-    const char* key, size_t klen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_delete_cf(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush_wal(
-    rocksdb_transactiondb_t* txn_db, unsigned char sync, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options,
-    char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush_cf(
-    rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, char** errptr);
@@ -1,58 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/generate_c_api.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Source: tools/c_api_gen/spec.json
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/generate_c_api.py
-//     --spec tools/c_api_gen/spec.json --section 'WriteBatch'
-//     --header-out
-//     c_api_gen/c_generated_writebatch_subset.h.inc
-//     --source-out
-//     c_api_gen/c_generated_writebatch_subset.cc.inc
-
-/* WriteBatch */
-
-void rocksdb_writebatch_clear(rocksdb_writebatch_t* b) { b->rep.Clear(); }
-
-void rocksdb_writebatch_put(rocksdb_writebatch_t* b, const char* key,
-                            size_t klen, const char* val, size_t vlen) {
-  b->rep.Put(Slice(key, klen), Slice(val, vlen));
-}
-
-void rocksdb_writebatch_put_cf(rocksdb_writebatch_t* b,
-                               rocksdb_column_family_handle_t* column_family,
-                               const char* key, size_t klen, const char* val,
-                               size_t vlen) {
-  b->rep.Put(column_family->rep, Slice(key, klen), Slice(val, vlen));
-}
-
-void rocksdb_writebatch_delete(rocksdb_writebatch_t* b, const char* key,
-                               size_t klen) {
-  b->rep.Delete(Slice(key, klen));
-}
-
-void rocksdb_writebatch_put_log_data(rocksdb_writebatch_t* b, const char* blob,
-                                     size_t len) {
-  b->rep.PutLogData(Slice(blob, len));
-}
-
-void rocksdb_writebatch_set_save_point(rocksdb_writebatch_t* b) {
-  b->rep.SetSavePoint();
-}
-
-void rocksdb_writebatch_rollback_to_save_point(rocksdb_writebatch_t* b,
-                                               char** errptr) {
-  SaveError(errptr, b->rep.RollbackToSavePoint());
-}
-
-void rocksdb_writebatch_pop_save_point(rocksdb_writebatch_t* b, char** errptr) {
-  SaveError(errptr, b->rep.PopSavePoint());
-}
-
-void rocksdb_writebatch_verify_checksum(rocksdb_writebatch_t* b,
-                                        char** errptr) {
-  SaveError(errptr, b->rep.VerifyChecksum());
-}
@@ -1,47 +0,0 @@
-// @generated
-// -----------------------------------------------------------------------------
-// Auto-generated by tools/c_api_gen/generate_c_api.py.
-// DO NOT EDIT THIS FILE DIRECTLY.
-// Source: tools/c_api_gen/spec.json
-// -----------------------------------------------------------------------------
-
-// To regenerate this file:
-//   python3 tools/c_api_gen/generate_c_api.py
-//     --spec tools/c_api_gen/spec.json --section 'WriteBatch'
-//     --header-out
-//     c_api_gen/c_generated_writebatch_subset.h.inc
-//     --source-out
-//     c_api_gen/c_generated_writebatch_subset.cc.inc
-
-/* WriteBatch */
-
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_clear(
-    rocksdb_writebatch_t* b);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_put(rocksdb_writebatch_t* b,
-                                                       const char* key,
-                                                       size_t klen,
-                                                       const char* val,
-                                                       size_t vlen);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_put_cf(
-    rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family,
-    const char* key, size_t klen, const char* val, size_t vlen);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_delete(
-    rocksdb_writebatch_t* b, const char* key, size_t klen);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_put_log_data(
-    rocksdb_writebatch_t* b, const char* blob, size_t len);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_set_save_point(
-    rocksdb_writebatch_t* b);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_rollback_to_save_point(
-    rocksdb_writebatch_t* b, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_pop_save_point(
-    rocksdb_writebatch_t* b, char** errptr);
-
-extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_verify_checksum(
-    rocksdb_writebatch_t* b, char** errptr);
@@ -127,24 +127,6 @@ class OffsetableCacheKey : private CacheKey {
    return CacheKey(file_num_etc64_, offset_etc64_ ^ offset);
  }

-  // Construct a CacheKey for a record located at byte `offset` within a file in
-  // which every distinct cached region is at least 5 bytes long. The low two
-  // offset bits are dropped, which is collision-free under that >= 5-byte (>= 4
-  // would suffice) guarantee and lets different kinds of records in the same
-  // file share a single keyspace without colliding.
-  //
-  // This is the canonical cache-key scheme for byte-offset records that carry
-  // the block-based "min 5 byte" guarantee: block-based SST blocks (see
-  // BlockBasedTable::GetCacheKey) and SimpleGen2Blob records (which always
-  // include a >= 5-byte trailer; see db/blob/blob_gen2_format.h). Because both
-  // use this same function, an SST's data blocks and its embedded blob records
-  // never collide even when the block cache and blob cache are the same cache.
-  // Keeping a single implementation here avoids a divergence bug that would
-  // silently alias the two keyspaces.
-  inline CacheKey WithOffsetForMinSizeRecord(uint64_t offset) const {
-    return WithOffset(offset >> 2);
-  }
-
  // The "common prefix" is a shared prefix for all the returned CacheKeys.
  // It is specific to the file but the same for all offsets within the file.
  static constexpr size_t kCommonPrefixSize = 8;
@@ -3108,7 +3108,7 @@ AutoHyperClockTable::HandleImpl* AutoHyperClockTable::Lookup(
  HandleImpl* const arr = array_.Get();
  NextWithShift next_with_shift = arr[home].head_next_with_shift.LoadRelaxed();
  for (size_t i = 0; !next_with_shift.IsEnd() && i < 10; ++i) {
-    HandleImpl* h = &arr[next_with_shift.GetNext()];
+    HandleImpl* h = &arr[next_with_shift.IsEnd()];
    // Attempt cheap key match without acquiring a read ref. This could give a
    // false positive, which is re-checked after acquiring read ref, or false
    // negative, which is re-checked in the full Lookup. Also, this is a
@@ -46,7 +46,7 @@ This document provides guidance on how to add new options to RocksDB's public AP

 ## Pattern 1: Adding a Standard Column Family Option

-Example reference: commit `94e65a2e0b4f817aa4bfa4c96cdf867e7980d7bc` (memtable_verify_per_key_checksum_on_seek)
+Example reference: commit `94e65a2e0b4f817aa4bfa4c96cdf867e7980d7bc` (memtable_veirfy_per_key_checksum_on_seek)

 ### Step 1: Define the Option in Public Header

@@ -63,7 +63,7 @@ Add the option with documentation in `AdvancedColumnFamilyOptions` struct:
 // operation.
 // This option depends on memtable_protection_bytes_per_key to be non zero.
 // If memtable_protection_bytes_per_key is zero, no validation is performed.
-bool memtable_verify_per_key_checksum_on_seek = false;
+bool memtable_veirfy_per_key_checksum_on_seek = false;
 ```

 ### Step 2: Add to Internal Options Structs
@@ -74,14 +74,14 @@ Add to `MutableCFOptions` struct (or `ImmutableCFOptions` for immutable options)

 ```cpp
 // In MutableCFOptions constructor from Options:
-memtable_verify_per_key_checksum_on_seek(
-    options.memtable_verify_per_key_checksum_on_seek),
+memtable_veirfy_per_key_checksum_on_seek(
+    options.memtable_veirfy_per_key_checksum_on_seek),

 // In MutableCFOptions default constructor:
-memtable_verify_per_key_checksum_on_seek(false),
+memtable_veirfy_per_key_checksum_on_seek(false),

 // In MutableCFOptions struct member declarations:
-bool memtable_verify_per_key_checksum_on_seek;
+bool memtable_veirfy_per_key_checksum_on_seek;
 ```

 ### Step 3: Register for Serialization/Deserialization
@@ -91,9 +91,9 @@ bool memtable_verify_per_key_checksum_on_seek;
 Add to the options type info map for serialization:

 ```cpp
-{"memtable_verify_per_key_checksum_on_seek",
+{"memtable_veirfy_per_key_checksum_on_seek",
 {offsetof(struct MutableCFOptions,
-           memtable_verify_per_key_checksum_on_seek),
+           memtable_veirfy_per_key_checksum_on_seek),
  OptionType::kBoolean, OptionVerificationType::kNormal,
  OptionTypeFlags::kMutable}},
 ```
@@ -101,8 +101,8 @@ Add to the options type info map for serialization:
 Add logging in `MutableCFOptions::Dump()`:

 ```cpp
-ROCKS_LOG_INFO(log, "memtable_verify_per_key_checksum_on_seek: %d",
-               memtable_verify_per_key_checksum_on_seek);
+ROCKS_LOG_INFO(log, "memtable_veirfy_per_key_checksum_on_seek: %d",
+               memtable_veirfy_per_key_checksum_on_seek);
 ```

 ### Step 4: Update Options Helper
@@ -112,8 +112,8 @@ ROCKS_LOG_INFO(log, "memtable_verify_per_key_checksum_on_seek: %d",
 Add to `UpdateColumnFamilyOptions()`:

 ```cpp
-cf_opts->memtable_verify_per_key_checksum_on_seek =
-    moptions.memtable_verify_per_key_checksum_on_seek;
+cf_opts->memtable_veirfy_per_key_checksum_on_seek =
+    moptions.memtable_veirfy_per_key_checksum_on_seek;
 ```

 ### Step 5: Add to Options Settable Test
@@ -123,7 +123,7 @@ cf_opts->memtable_verify_per_key_checksum_on_seek =
 Add to the test string in `ColumnFamilyOptionsAllFieldsSettable`:

 ```cpp
-"memtable_verify_per_key_checksum_on_seek=1;"
+"memtable_veirfy_per_key_checksum_on_seek=1;"
 ```

 ### Step 6: Add db_stress Support
@@ -131,23 +131,23 @@ Add to the test string in `ColumnFamilyOptionsAllFieldsSettable`:
 **File: `db_stress_tool/db_stress_common.h`**

 ```cpp
-DECLARE_bool(memtable_verify_per_key_checksum_on_seek);
+DECLARE_bool(memtable_veirfy_per_key_checksum_on_seek);
 ```

 **File: `db_stress_tool/db_stress_gflags.cc`**

 ```cpp
 DEFINE_bool(
-    memtable_verify_per_key_checksum_on_seek,
-    ROCKSDB_NAMESPACE::Options().memtable_verify_per_key_checksum_on_seek,
-    "Sets CF option memtable_verify_per_key_checksum_on_seek.");
+    memtable_veirfy_per_key_checksum_on_seek,
+    ROCKSDB_NAMESPACE::Options().memtable_veirfy_per_key_checksum_on_seek,
+    "Sets CF option memtable_veirfy_per_key_checksum_on_seek.");
 ```

 **File: `db_stress_tool/db_stress_test_base.cc`**

 ```cpp
-options.memtable_verify_per_key_checksum_on_seek =
-    FLAGS_memtable_verify_per_key_checksum_on_seek;
+options.memtable_veirfy_per_key_checksum_on_seek =
+    FLAGS_memtable_veirfy_per_key_checksum_on_seek;
 ```

 ### Step 7: Add db_bench Support
@@ -156,12 +156,12 @@ options.memtable_verify_per_key_checksum_on_seek =

 ```cpp
 // Flag definition (near related flags):
-DEFINE_bool(memtable_verify_per_key_checksum_on_seek, false,
-            "Sets CF option memtable_verify_per_key_checksum_on_seek");
+DEFINE_bool(memtable_veirfy_per_key_checksum_on_seek, false,
+            "Sets CF option memtable_veirfy_per_key_checksum_on_seek");

 // Apply flag to options (in InitializeOptionsFromFlags or similar):
-options.memtable_verify_per_key_checksum_on_seek =
-    FLAGS_memtable_verify_per_key_checksum_on_seek;
+options.memtable_veirfy_per_key_checksum_on_seek =
+    FLAGS_memtable_veirfy_per_key_checksum_on_seek;
 ```

 ### Step 8: Add Crash Test Support
@@ -169,7 +169,7 @@ options.memtable_verify_per_key_checksum_on_seek =
 **File: `tools/db_crashtest.py`**

 ```python
-"memtable_verify_per_key_checksum_on_seek": lambda: random.choice([0] * 7 + [1]),
+"memtable_veirfy_per_key_checksum_on_seek": lambda: random.choice([0] * 7 + [1]),
 ```

 Also add constraint handling in `finalize_and_sanitize()` if needed:
@@ -177,7 +177,7 @@ Also add constraint handling in `finalize_and_sanitize()` if needed:
 ```python
 # only skip list memtable representation supports paranoid memory checks
 if dest_params.get("memtablerep") != "skip_list":
-    dest_params["memtable_verify_per_key_checksum_on_seek"] = 0
+    dest_params["memtable_veirfy_per_key_checksum_on_seek"] = 0
 ```

 ### Step 9: Add Release Note
@@ -185,7 +185,7 @@ if dest_params.get("memtablerep") != "skip_list":
 **File: `unreleased_history/new_features/<descriptive_name>.md`**

 ```markdown
-A new flag memtable_verify_per_key_checksum_on_seek is added to AdvancedColumnFamilyOptions. When it is enabled, it will validate key checksum along the binary search path on skiplist based memtable during seek operation.
+A new flag memtable_veirfy_per_key_checksum_on_seek is added to AdvancedColumnFamilyOptions. When it is enabled, it will validate key checksum along the binary search path on skiplist based memtable during seek operation.
 ```

 ---
@@ -421,30 +421,6 @@ Example reference: commit `429b36c22d76403d275dd0e6877b08d4cea2bc90` (block_alig

 If an option already exists but needs C API support:

-**First decide whether the option is auto-managed.**
-
-Many simple option fields are no longer maintained by hand in
-`include/rocksdb/c.h` and `db/c.cc`. Before adding a manual wrapper:
-
- Check whether the option belongs to a family handled by
-  `tools/c_api_gen/auto_simple_bindings.py`.
- If it is a simple scalar/enum/string field in an auto-managed family, run
-  `python3 tools/c_api_gen/regen_all.py` and let the generator add the C API.
- After regenerating, run
-  `python3 tools/c_api_gen/verify_generated_up_to_date.py` to confirm the
-  checked-in generated fragments stay stable.
- Do not edit generated `.inc` files under `c_api_gen/` by hand.
- If the new field is not ready for C API support yet, add an entry to
-  `tools/c_api_gen/auto_simple_bindings_blocklist.json` with
-  `"policy": "deferred"` and a concrete reason so the build stays intentional
-  rather than silently drifting.
- If the field needs custom ownership, callback, vector, or nested-struct
-  marshalling, keep it manual or move it into `tools/c_api_gen/spec.json`
-  depending on the API shape.
-
-If the option is not auto-managed, or the C API really is a custom/manual case,
-the traditional hand-written pattern still applies:
-
 **File: `db/c.cc`**

 ```cpp
@@ -533,3 +509,4 @@ Common option types used in serialization:
 - [ ] unreleased_history markdown file
 - [ ] Java API (for BlockBasedTableOptions)
 - [ ] C API (if needed)
+
@@ -168,18 +168,9 @@ Status YourNewAPI(const YourAPIOptions& /*options*/,

 ### Step 5: Add C API Bindings

-> **Important:** `include/rocksdb/c.h` and `db/c.cc` are `@generated` and must
-> NOT be edited by hand — your changes would be overwritten on the next
-> regeneration. Choose the right path first (see "Before writing C API code by
-> hand" below). For hand-written (manual) wrappers, edit the source templates
-> `tools/c_api_gen/c_base.h` (declarations) and `tools/c_api_gen/c_base.cc`
-> (implementations), then run `python3 tools/c_api_gen/regen_all.py` to produce
-> `c.h` / `c.cc`. The snippets below show the *declaration* and *implementation*
-> you would add to those templates.
+**Header:** `include/rocksdb/c.h`

-**Header (declaration → `tools/c_api_gen/c_base.h`):**
-
-```c
+\`\`\`c
 // Basic version
 extern ROCKSDB_LIBRARY_API void rocksdb_your_new_api(
    rocksdb_t* db,
@@ -200,7 +191,7 @@ extern ROCKSDB_LIBRARY_API void rocksdb_your_new_api_opt(
    char** errptr);
 \`\`\`

-**Implementation (→ `tools/c_api_gen/c_base.cc`):**
+**Implementation:** `db/c.cc`

 \`\`\`cpp
 void rocksdb_your_new_api(rocksdb_t* db, const char* start_key,
@@ -226,38 +217,6 @@ void rocksdb_your_new_api_cf(rocksdb_t* db,
 }
 \`\`\`

-**Before writing C API code by hand, choose the right path:**
-
- **Auto-managed simple struct fields:** If you added a new field to a managed
-  public struct such as `ReadOptions`, selected option structs, or managed
-  metadata structs, first check `tools/c_api_gen/auto_simple_bindings.py`.
-  Simple scalar/enum/string fields should be regenerated with
-  `python3 tools/c_api_gen/regen_all.py` rather than hand-editing
-  `include/rocksdb/c.h` / `db/c.cc`.
-  After regenerating, run
-  `python3 tools/c_api_gen/verify_generated_up_to_date.py` to confirm the
-  checked-in generated fragments are stable.
- **Spec-driven wrappers:** If the API is still mechanically generated but needs
-  an explicit C shape, naming, or `Status`/`char** errptr` policy, add it to
-  `tools/c_api_gen/spec.json`.
- **Fully manual wrappers:** If the API uses callbacks, ownership transfer,
-  vectors/maps, open flows, or otherwise irregular marshalling, keep the C API
-  hand-written.
-
-**Temporary deferral for auto-managed families:**
-
-If a new field lands in an auto-managed family but the C API shape is not ready
-yet, add a checked-in entry to
-`tools/c_api_gen/auto_simple_bindings_blocklist.json` with:
-
- `policy: "manual"` when the field is intentionally outside simple auto-gen
- `policy: "deferred"` when the field should be revisited later
- a concrete `reason`
- `tracking_issue` when available
-
-If a field in an auto-managed family is not supported by the generator and is
-not covered by the blocklist, regeneration should fail. That is intentional.
-
 **If you have options, also add:**

 \`\`\`cpp
@@ -523,8 +482,8 @@ public class YourAPIOptionsTest {
 | StackableDB | `include/rocksdb/utilities/stackable_db.h` | ✓ |
 | Secondary DB | `db/db_impl/db_impl_secondary.h` | If not supported |
 | Compacted DB | `db/db_impl/compacted_db_impl.h` | If not supported |
-| C API Header (manual wrappers) | `tools/c_api_gen/c_base.h` → regen → `include/rocksdb/c.h` (`@generated`) | ✓ |
-| C API Implementation (manual wrappers) | `tools/c_api_gen/c_base.cc` → regen → `db/c.cc` (`@generated`) | ✓ |
+| C API Header | `include/rocksdb/c.h` | ✓ |
+| C API Implementation | `db/c.cc` | ✓ |
 | Java API | `java/src/main/java/org/rocksdb/RocksDB.java` | ✓ |
 | Java Options | `java/src/main/java/org/rocksdb/YourAPIOptions.java` | If needed |
 | JNI Implementation | `java/rocksjni/rocksjni.cc` | ✓ |
@@ -44,6 +44,10 @@ if(@WITH_NUMA@)
  find_dependency(NUMA)
 endif()

+if(@WITH_TBB@)
+  find_dependency(TBB)
+endif()
+
 find_dependency(Threads)

 include("${CMAKE_CURRENT_LIST_DIR}/RocksDBTargets.cmake")
@@ -0,0 +1,33 @@
+# - Find TBB
+# Find the Thread Building Blocks library and includes
+#
+# TBB_INCLUDE_DIRS - where to find tbb.h, etc.
+# TBB_LIBRARIES - List of libraries when using TBB.
+# TBB_FOUND - True if TBB found.
+
+if(NOT DEFINED TBB_ROOT_DIR)
+  set(TBB_ROOT_DIR "$ENV{TBBROOT}")
+endif()
+
+find_path(TBB_INCLUDE_DIRS
+  NAMES tbb/tbb.h
+  HINTS ${TBB_ROOT_DIR}/include)
+
+find_library(TBB_LIBRARIES
+  NAMES tbb
+  HINTS ${TBB_ROOT_DIR}/lib ENV LIBRARY_PATH)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(TBB DEFAULT_MSG TBB_LIBRARIES TBB_INCLUDE_DIRS)
+
+mark_as_advanced(
+  TBB_LIBRARIES
+  TBB_INCLUDE_DIRS)
+
+if(TBB_FOUND AND NOT (TARGET TBB::TBB))
+  add_library (TBB::TBB UNKNOWN IMPORTED)
+  set_target_properties(TBB::TBB
+    PROPERTIES
+      IMPORTED_LOCATION ${TBB_LIBRARIES}
+      INTERFACE_INCLUDE_DIRECTORIES ${TBB_INCLUDE_DIRS})
+endif()
@@ -7,13 +7,6 @@ DB_STRESS_CMD?=./db_stress

 include common.mk

-ifdef COMPILE_WITH_TSAN
-	# Keep direct `make -f crash_test.mk COMPILE_WITH_TSAN=1 ...` runs
-	# aligned with the main Makefile's TSAN runtime options.
-	TSAN_OPTIONS?=suppressions=$(CURDIR)/tools/tsan_suppressions.txt
-	export TSAN_OPTIONS
-endif
-
 CRASHTEST_MAKE=$(MAKE) -f crash_test.mk
 CRASHTEST_PY=$(PYTHON) -u tools/db_crashtest.py --stress_cmd=$(DB_STRESS_CMD) --cleanup_cmd='$(DB_CLEANUP_CMD)' --destroy_db_initially=1

@@ -30,78 +30,13 @@ inline static SequenceNumber GetSeqNum(const DBImpl* db, const Snapshot* s) {
 Status ArenaWrappedDBIter::GetProperty(std::string prop_name,
                                       std::string* prop) {
  if (prop_name == "rocksdb.iterator.super-version-number") {
-    if (!internal_iter_initialized_) {
-      *prop = std::to_string(sv_number_);
-      return Status::OK();
-    }
    // First try to pass the value returned from inner iterator.
    if (!db_iter_->GetProperty(prop_name, prop).ok()) {
      *prop = std::to_string(sv_number_);
    }
    return Status::OK();
  }
-  if (!EnsureInternalIteratorInitialized(nullptr).ok()) {
-    return db_iter_->status();
-  }
-  return db_iter_->GetProperty(std::move(prop_name), prop);
-}
-
-void ArenaWrappedDBIter::CleanupDeferredSuperVersion() {
-  if (deferred_sv_ != nullptr) {
-    assert(db_impl_ != nullptr);
-    db_impl_->CleanupIteratorSuperVersion(
-        deferred_sv_, read_options_.background_purge_on_iterator_cleanup);
-    deferred_sv_ = nullptr;
-  }
-}
-
-void ArenaWrappedDBIter::DestroyDBIter() {
-  db_iter_->~DBIter();
-  CleanupDeferredSuperVersion();
-}
-
-void ArenaWrappedDBIter::ColumnFamilyDataUnrefDeleter::operator()(
-    ColumnFamilyData* cfd) const {
-  if (cfd == nullptr) {
-    return;
-  }
-  assert(db_impl != nullptr);
-
-  InstrumentedMutexLock lock(db_impl->mutex());
-  cfd->UnrefAndTryDelete();
-}
-
-void ArenaWrappedDBIter::DestroyDBIterAndArena() {
-  DestroyDBIter();
-  arena_.~Arena();
-}
-
-Status ArenaWrappedDBIter::EnsureInternalIteratorInitialized(
-    const MultiScanArgs* scan_opts) {
-  if (internal_iter_initialized_) {
-    return Status::OK();
-  }
-  if (db_impl_ == nullptr || deferred_cfd_ == nullptr ||
-      deferred_sv_ == nullptr) {
-    Status s = Status::InvalidArgument(
-        "Internal iterator cannot be initialized without deferred DB state");
-    db_iter_->set_status(s);
-    db_iter_->set_valid(false);
-    return s;
-  }
-
-  const MultiScanArgs* pruning_scan_opts =
-      scan_opts != nullptr && scan_opts->HasBoundedScanRanges() ? scan_opts
-                                                                : nullptr;
-  child_read_options_ = read_options_;
-  child_read_options_.snapshot = nullptr;
-  InternalIterator* internal_iter = db_impl_->NewInternalIterator(
-      child_read_options_, deferred_cfd_, deferred_sv_, &arena_, sequence_,
-      /*allow_unprepared_value=*/true, this, pruning_scan_opts);
-  deferred_cfd_ = nullptr;
-  deferred_sv_ = nullptr;
-  SetIterUnderDBIterImpl(internal_iter);
-  return Status::OK();
+  return db_iter_->GetProperty(prop_name, prop);
 }

 void ArenaWrappedDBIter::Init(
@@ -109,26 +44,18 @@ void ArenaWrappedDBIter::Init(
    const MutableCFOptions& mutable_cf_options, const Version* version,
    const SequenceNumber& sequence, uint64_t version_number,
    ReadCallback* read_callback, ColumnFamilyHandleImpl* cfh,
-    bool expose_blob_index, bool allow_refresh, ReadOnlyMemTable* active_mem,
-    DBImpl* db_impl, ColumnFamilyData* cfd) {
+    bool expose_blob_index, bool allow_refresh, ReadOnlyMemTable* active_mem) {
  read_options_ = read_options;
-  child_read_options_ = read_options;
  if (!CheckFSFeatureSupport(env->GetFileSystem().get(),
                             FSSupportedOps::kAsyncIO)) {
    read_options_.async_io = false;
  }
  read_options_.total_order_seek |= ioptions.prefix_seek_opt_in_only;

-  if (cfh != nullptr) {
-    db_impl = cfh->db();
-    cfd = cfh->cfd();
-  }
-
-  db_iter_ = DBIter::NewIter(env, read_options_, ioptions, mutable_cf_options,
-                             ioptions.user_comparator,
-                             /*internal_iter=*/nullptr, version, sequence,
-                             read_callback, active_mem, /*cfh=*/nullptr,
-                             expose_blob_index, &arena_, db_impl, cfd);
+  db_iter_ = DBIter::NewIter(
+      env, read_options_, ioptions, mutable_cf_options,
+      ioptions.user_comparator, /*internal_iter=*/nullptr, version, sequence,
+      read_callback, active_mem, cfh, expose_blob_index, &arena_);

  sv_number_ = version_number;
  allow_refresh_ = allow_refresh;
@@ -138,13 +65,13 @@ void ArenaWrappedDBIter::Init(

 void ArenaWrappedDBIter::MaybeAutoRefresh(bool is_seek,
                                          DBIter::Direction direction) {
-  if (cfd_ref_ != nullptr && read_options_.snapshot != nullptr &&
-      allow_refresh_ && read_options_.auto_refresh_iterator_with_snapshot) {
+  if (cfh_ != nullptr && read_options_.snapshot != nullptr && allow_refresh_ &&
+      read_options_.auto_refresh_iterator_with_snapshot) {
    // The intent here is to capture the superversion number change
    // reasonably soon from the time it actually happened. As such,
    // we're fine with weaker synchronization / ordering guarantees
    // provided by relaxed atomic (in favor of less CPU / mem overhead).
-    uint64_t cur_sv_number = cfd_ref_->GetSuperVersionNumberRelaxed();
+    uint64_t cur_sv_number = cfh_->cfd()->GetSuperVersionNumberRelaxed();
    if ((sv_number_ != cur_sv_number) && status().ok()) {
      // Changing iterators' direction is pretty heavy-weight operation and
      // could have unintended consequences when it comes to prefix seek.
@@ -223,13 +150,13 @@ void ArenaWrappedDBIter::DoRefresh(const Snapshot* snapshot,
  // present in the error log, but won't be reflected in the iterator status.
  // This is by design as we expect compaction to clean up those obsolete files
  // eventually.
-  DestroyDBIterAndArena();
+  db_iter_->~DBIter();
+
+  arena_.~Arena();
  new (&arena_) Arena();

-  auto cfd = cfd_ref_.get();
-  auto db_impl = db_impl_;
-  assert(cfd != nullptr);
-  assert(db_impl != nullptr);
+  auto cfd = cfh_->cfd();
+  auto db_impl = cfh_->db();

  SuperVersion* sv = cfd->GetReferencedSuperVersion(db_impl);
  assert(sv->version_number >= sv_number);
@@ -237,27 +164,23 @@ void ArenaWrappedDBIter::DoRefresh(const Snapshot* snapshot,
  if (read_callback_) {
    read_callback_->Refresh(read_seq);
  }
-  // TODO: Preserve Prepare() scan options across Refresh() so a refreshed
-  // MultiScan iterator can rebuild the same pruned tree.
  Init(env, read_options_, cfd->ioptions(), sv->mutable_cf_options, sv->current,
-       read_seq, sv->version_number, read_callback_, nullptr,
-       expose_blob_index_, allow_refresh_,
-       allow_mark_memtable_for_flush_ ? sv->mem : nullptr, db_impl, cfd);
+       read_seq, sv->version_number, read_callback_, cfh_, expose_blob_index_,
+       allow_refresh_, allow_mark_memtable_for_flush_ ? sv->mem : nullptr);

  InternalIterator* internal_iter = db_impl->NewInternalIterator(
      read_options_, cfd, sv, &arena_, read_seq,
      /* allow_unprepared_value */ true, /* db_iter */ this);
  SetIterUnderDBIter(internal_iter);
-  internal_iter_initialized_ = true;
 }

 Status ArenaWrappedDBIter::Refresh(const Snapshot* snapshot) {
-  if (cfd_ref_ == nullptr || db_impl_ == nullptr || !allow_refresh_) {
+  if (cfh_ == nullptr || !allow_refresh_) {
    return Status::NotSupported("Creating renew iterator is not allowed.");
  }
  assert(db_iter_ != nullptr);
-  auto cfd = cfd_ref_.get();
-  auto db_impl = db_impl_;
+  auto cfd = cfh_->cfd();
+  auto db_impl = cfh_->db();

  // TODO(yiwu): For last_seq_same_as_publish_seq_==false, this is not the
  // correct behavior. Will be corrected automatically when we take a snapshot
@@ -270,13 +193,6 @@ Status ArenaWrappedDBIter::Refresh(const Snapshot* snapshot) {
  TEST_SYNC_POINT("ArenaWrappedDBIter::Refresh:1");
  TEST_SYNC_POINT("ArenaWrappedDBIter::Refresh:2");

-  if (!internal_iter_initialized_) {
-    Status s = EnsureInternalIteratorInitialized(nullptr);
-    if (!s.ok()) {
-      return s;
-    }
-  }
-
  while (true) {
    if (sv_number_ != cur_sv_number) {
      DoRefresh(snapshot, cur_sv_number);
@@ -334,47 +250,25 @@ Status ArenaWrappedDBIter::Refresh(const Snapshot* snapshot) {
  return Status::OK();
 }

-void ArenaWrappedDBIter::Prepare(const MultiScanArgs& scan_opts) {
-  if (prepare_called_) {
-    db_iter_->set_status(Status::InvalidArgument(
-        "Prepare called more than once on the same iterator"));
-    db_iter_->set_valid(false);
-    return;
-  }
-  prepare_called_ = true;
-
-  Status s = db_iter_->SetScanOptionsForPrepare(scan_opts);
-  if (!s.ok()) {
-    return;
-  }
-
-  const MultiScanArgs* pruning_scan_opts =
-      scan_opts.HasBoundedScanRanges() ? &scan_opts : nullptr;
-  s = EnsureInternalIteratorInitialized(pruning_scan_opts);
-  if (!s.ok()) {
-    return;
-  }
-
-  db_iter_->PrepareInternalChildren();
-}
-
 ArenaWrappedDBIter* NewArenaWrappedDbIterator(
    Env* env, const ReadOptions& read_options, ColumnFamilyHandleImpl* cfh,
    SuperVersion* sv, const SequenceNumber& sequence,
    ReadCallback* read_callback, DBImpl* db_impl, bool expose_blob_index,
    bool allow_refresh, bool allow_mark_memtable_for_flush) {
  ArenaWrappedDBIter* db_iter = new ArenaWrappedDBIter();
-  ColumnFamilyData* cfd = cfh->cfd();
  db_iter->Init(env, read_options, cfh->cfd()->ioptions(),
                sv->mutable_cf_options, sv->current, sequence,
                sv->version_number, read_callback, cfh, expose_blob_index,
                allow_refresh,
                allow_mark_memtable_for_flush ? sv->mem : nullptr);
-  if (allow_refresh && cfd != nullptr) {
-    db_iter->StoreRefreshInfo(read_callback, expose_blob_index);
+  if (cfh != nullptr && allow_refresh) {
+    db_iter->StoreRefreshInfo(cfh, read_callback, expose_blob_index);
  }
-  db_iter->StoreDeferredInitInfo(db_impl, cfd, sv, sequence,
-                                 allow_mark_memtable_for_flush);
+
+  InternalIterator* internal_iter = db_impl->NewInternalIterator(
+      db_iter->GetReadOptions(), cfh->cfd(), sv, db_iter->GetArena(), sequence,
+      /*allow_unprepared_value=*/true, db_iter);
+  db_iter->SetIterUnderDBIter(internal_iter);

  return db_iter;
 }
@@ -10,7 +10,6 @@
 #pragma once
 #include <stdint.h>

-#include <memory>
 #include <string>

 #include "db/db_impl/db_impl.h"
@@ -34,17 +33,10 @@ class Version;
 // When using the class's Iterator interface, the behavior is exactly
 // the same as the inner DBIter.
 class ArenaWrappedDBIter : public Iterator {
-  struct ColumnFamilyDataUnrefDeleter {
-    DBImpl* db_impl = nullptr;
-    void operator()(ColumnFamilyData* cfd) const;
-  };
-  using ColumnFamilyDataRef =
-      std::unique_ptr<ColumnFamilyData, ColumnFamilyDataUnrefDeleter>;
-
 public:
  ~ArenaWrappedDBIter() override {
    if (db_iter_ != nullptr) {
-      DestroyDBIter();
+      db_iter_->~DBIter();
    } else {
      assert(false);
    }
@@ -59,7 +51,7 @@ class ArenaWrappedDBIter : public Iterator {
  // Set the internal iterator wrapped inside the DB Iterator. Usually it is
  // a merging iterator.
  virtual void SetIterUnderDBIter(InternalIterator* iter) {
-    SetIterUnderDBIterImpl(iter);
+    db_iter_->SetIter(iter);
  }

  void SetMemtableRangetombstoneIter(
@@ -68,48 +60,26 @@ class ArenaWrappedDBIter : public Iterator {
  }

  bool Valid() const override { return db_iter_->Valid(); }
-  void SeekToFirst() override {
-    if (!EnsureInternalIteratorInitialized(nullptr).ok()) {
-      return;
-    }
-    db_iter_->SeekToFirst();
-  }
-  void SeekToLast() override {
-    if (!EnsureInternalIteratorInitialized(nullptr).ok()) {
-      return;
-    }
-    db_iter_->SeekToLast();
-  }
+  void SeekToFirst() override { db_iter_->SeekToFirst(); }
+  void SeekToLast() override { db_iter_->SeekToLast(); }
  // 'target' does not contain timestamp, even if user timestamp feature is
  // enabled.
  void Seek(const Slice& target) override {
-    if (!EnsureInternalIteratorInitialized(nullptr).ok()) {
-      return;
-    }
    MaybeAutoRefresh(true /* is_seek */, DBIter::kForward);
    db_iter_->Seek(target);
  }

  void SeekForPrev(const Slice& target) override {
-    if (!EnsureInternalIteratorInitialized(nullptr).ok()) {
-      return;
-    }
    MaybeAutoRefresh(true /* is_seek */, DBIter::kReverse);
    db_iter_->SeekForPrev(target);
  }

  void Next() override {
-    if (!EnsureInternalIteratorInitialized(nullptr).ok()) {
-      return;
-    }
    db_iter_->Next();
    MaybeAutoRefresh(false /* is_seek */, DBIter::kForward);
  }

  void Prev() override {
-    if (!EnsureInternalIteratorInitialized(nullptr).ok()) {
-      return;
-    }
    db_iter_->Prev();
    MaybeAutoRefresh(false /* is_seek */, DBIter::kReverse);
  }
@@ -126,12 +96,11 @@ class ArenaWrappedDBIter : public Iterator {
  Status Refresh() override;
  Status Refresh(const Snapshot*) override;

-  bool PrepareValue() override {
-    return EnsureInternalIteratorInitialized(nullptr).ok() &&
-           db_iter_->PrepareValue();
-  }
+  bool PrepareValue() override { return db_iter_->PrepareValue(); }

-  void Prepare(const MultiScanArgs& scan_opts) override;
+  void Prepare(const MultiScanArgs& scan_opts) override {
+    db_iter_->Prepare(scan_opts);
+  }

  // FIXME: we could just pass SV in for mutable cf option, version and version
  // number, but this is used by SstFileReader which does not have a SV.
@@ -141,53 +110,27 @@ class ArenaWrappedDBIter : public Iterator {
            const SequenceNumber& sequence, uint64_t version_number,
            ReadCallback* read_callback, ColumnFamilyHandleImpl* cfh,
            bool expose_blob_index, bool allow_refresh,
-            ReadOnlyMemTable* active_mem, DBImpl* db_impl = nullptr,
-            ColumnFamilyData* cfd = nullptr);
+            ReadOnlyMemTable* active_mem);

-  // Store parameters used only by explicit/auto-refresh.
-  void StoreRefreshInfo(ReadCallback* read_callback, bool expose_blob_index) {
+  // Store some parameters so we can refresh the iterator at a later point
+  // with these same params
+  void StoreRefreshInfo(ColumnFamilyHandleImpl* cfh,
+                        ReadCallback* read_callback, bool expose_blob_index) {
+    cfh_ = cfh;
    read_callback_ = read_callback;
    expose_blob_index_ = expose_blob_index;
  }

-  void StoreDeferredInitInfo(DBImpl* db_impl, ColumnFamilyData* cfd,
-                             SuperVersion* sv, const SequenceNumber& sequence,
-                             bool allow_mark_memtable_for_flush) {
-    assert(cfd != nullptr);
-    db_impl_ = db_impl;
-    cfd->Ref();
-    cfd_ref_ = ColumnFamilyDataRef(cfd, ColumnFamilyDataUnrefDeleter{db_impl});
-    deferred_cfd_ = cfd;
-    deferred_sv_ = sv;
-    sequence_ = sequence;
-    allow_mark_memtable_for_flush_ = allow_mark_memtable_for_flush;
-  }
-
 private:
-  Status EnsureInternalIteratorInitialized(const MultiScanArgs* scan_opts);
-  void SetIterUnderDBIterImpl(InternalIterator* iter) {
-    db_iter_->SetIter(iter);
-    internal_iter_initialized_ = true;
-  }
-  void CleanupDeferredSuperVersion();
-  void DestroyDBIter();
-  void DestroyDBIterAndArena();
  void DoRefresh(const Snapshot* snapshot, uint64_t sv_number);
  void MaybeAutoRefresh(bool is_seek, DBIter::Direction direction);

  DBIter* db_iter_ = nullptr;
  Arena arena_;
-  uint64_t sv_number_ = 0;
-  DBImpl* db_impl_ = nullptr;
-  ColumnFamilyDataRef cfd_ref_{nullptr, ColumnFamilyDataUnrefDeleter{}};
-  ColumnFamilyData* deferred_cfd_ = nullptr;
-  SuperVersion* deferred_sv_ = nullptr;
-  SequenceNumber sequence_ = kMaxSequenceNumber;
-  bool internal_iter_initialized_ = false;
-  bool prepare_called_ = false;
+  uint64_t sv_number_;
+  ColumnFamilyHandleImpl* cfh_ = nullptr;
  ReadOptions read_options_;
-  ReadOptions child_read_options_;
-  ReadCallback* read_callback_ = nullptr;
+  ReadCallback* read_callback_;
  bool expose_blob_index_ = false;
  bool allow_refresh_ = true;
  bool allow_mark_memtable_for_flush_ = true;
@@ -11,24 +11,6 @@

 namespace ROCKSDB_NAMESPACE {

-// WARNING: This value is == kCurrentFileBlobIndexFileNumber.
-// Use this name only where file number zero means "no valid blob file" or
-// "current file" is not understood/supported.
 constexpr uint64_t kInvalidBlobFileNumber = 0;

-// WARNING: This value is == kInvalidBlobFileNumber.
-// Use this name only for BlobIndex references to the same physical file as what
-// is currently being read; generic blob-file metadata must treat zero as
-// invalid. (Using a distinct value like 1 was found to be more problematic,
-// e.g. because of legacy "stackable" blob implementation.)
-//
-// This "zero is invalid unless you are the embedded reader/writer" contract is
-// enforced by integrity checks that reject file number zero on generic paths;
-// see FileMetaData::UpdateBoundaries (write/output path) and Version::GetBlob /
-// Version::MultiGetBlob (read path). Same-file references must be resolved (by
-// EmbeddedBlobResolvingIterator) before they reach those paths. Do not weaken
-// those checks -- they catch leaks/corruption closer to the root cause.
-constexpr uint64_t kCurrentFileBlobIndexFileNumber = kInvalidBlobFileNumber;
-static_assert(kCurrentFileBlobIndexFileNumber == kInvalidBlobFileNumber);
-
 }  // namespace ROCKSDB_NAMESPACE
@@ -14,6 +14,8 @@
 #include "db/blob/blob_log_format.h"
 #include "db/blob/blob_log_writer.h"
 #include "db/blob/blob_source.h"
+#include "db/blog/blog_format.h"
+#include "db/blog/blog_writer.h"
 #include "db/event_helpers.h"
 #include "db/version_set.h"
 #include "file/filename.h"
@@ -22,7 +24,6 @@
 #include "logging/logging.h"
 #include "options/cf_options.h"
 #include "options/options_helper.h"
-#include "rocksdb/file_system.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/status.h"
 #include "test_util/sync_point.h"
@@ -68,10 +69,13 @@ BlobFileBuilder::BlobFileBuilder(
      min_blob_size_(mutable_cf_options->min_blob_size),
      blob_file_size_(mutable_cf_options->blob_file_size),
      blob_compression_type_(mutable_cf_options->blob_compression_type),
-      // TODO with schema change: support custom compression manager and options
-      // such as max_compressed_bytes_per_kb
-      // NOTE: returns nullptr for kNoCompression
-      blob_compressor_(GetBuiltinV2CompressionManager()->GetCompressor(
+      // Blog format uses the CF's compression manager; legacy format must
+      // use the builtin for compatibility.
+      blob_compression_manager_(immutable_options->use_blog_format_for_blobs &&
+                                        mutable_cf_options->compression_manager
+                                    ? mutable_cf_options->compression_manager
+                                    : GetBuiltinV2CompressionManager()),
+      blob_compressor_(blob_compression_manager_->GetCompressor(
          mutable_cf_options->blob_compression_opts, blob_compression_type_)),
      blob_compressor_wa_(blob_compressor_
                              ? blob_compressor_->ObtainWorkingArea()
@@ -124,8 +128,10 @@ Status BlobFileBuilder::Add(const Slice& key, const Slice& value,
  Slice blob = value;
  GrowableBuffer compressed_blob;

-  {
-    const Status s = CompressBlobIfNeeded(&blob, &compressed_blob);
+  if (!blog_writer_) {
+    // Legacy format: compress before writing (compression type is implicit
+    // from the configured blob_compression_type_).
+    const Status s = LegacyCompressBlob(&blob, &compressed_blob);
    if (!s.ok()) {
      return s;
    }
@@ -133,10 +139,13 @@ Status BlobFileBuilder::Add(const Slice& key, const Slice& value,

  uint64_t blob_file_number = 0;
  uint64_t blob_offset = 0;
+  uint64_t blob_on_disk_size = 0;
+  CompressionType actual_compression_type = blob_compression_type_;

  {
    const Status s =
-        WriteBlobToFile(key, blob, &blob_file_number, &blob_offset);
+        WriteBlobToFile(key, blob, &blob_file_number, &blob_offset,
+                        &blob_on_disk_size, &actual_compression_type);
    if (!s.ok()) {
      return s;
    }
@@ -159,8 +168,8 @@ Status BlobFileBuilder::Add(const Slice& key, const Slice& value,
    }
  }

-  BlobIndex::EncodeBlob(blob_index, blob_file_number, blob_offset, blob.size(),
-                        blob_compression_type_);
+  BlobIndex::EncodeBlob(blob_index, blob_file_number, blob_offset,
+                        blob_on_disk_size, actual_compression_type);

  return Status::OK();
 }
@@ -173,7 +182,9 @@ Status BlobFileBuilder::Finish() {
  return CloseBlobFile();
 }

-bool BlobFileBuilder::IsBlobFileOpen() const { return !!writer_; }
+bool BlobFileBuilder::IsBlobFileOpen() const {
+  return !!writer_ || !!blog_writer_;
+}

 Status BlobFileBuilder::OpenBlobFileIfNeeded() {
  if (IsBlobFileOpen()) {
@@ -201,8 +212,6 @@ Status BlobFileBuilder::OpenBlobFileIfNeeded() {
  {
    assert(file_options_);
    fo_copy = *file_options_;
-    fo_copy.open_contract = FileOpenContract::kNoReopenForWrite |
-                            FileOpenContract::kNoReadersWhileOpenForWrite;
    fo_copy.write_hint = write_hint_;
    Status s = NewWritableFile(fs_, blob_file_path, &file, fo_copy);

@@ -234,37 +243,73 @@ Status BlobFileBuilder::OpenBlobFileIfNeeded() {
      immutable_options_->file_checksum_gen_factory.get(),
      tmp_set.Contains(FileType::kBlobFile), false));

-  constexpr bool do_flush = false;
+  blob_file_number_ = blob_file_number;

-  std::unique_ptr<BlobLogWriter> blob_log_writer(new BlobLogWriter(
-      std::move(file_writer), immutable_options_->clock, statistics,
-      blob_file_number, immutable_options_->use_fsync, do_flush));
+  if (immutable_options_->use_blog_format_for_blobs) {
+    // Blog format path
+    BlogFileHeader blog_header;
+    blog_header.checksum_type = immutable_options_->blog_checksum;
+    blog_header.compact_record_type = kBlogBlobRecord;
+    blog_header.GenerateFromUniqueId(db_id_, db_session_id_, blob_file_number);
+    blog_header.SetProperty(kBlogPropRole, "blob");
+    if (!immutable_options_->db_host_id.empty()) {
+      blog_header.SetProperty(kBlogPropDbHostId,
+                              immutable_options_->db_host_id);
+    }
+    blog_header.SetUint32Property(kBlogPropColumnFamilyId, column_family_id_);
+    if (!column_family_name_.empty()) {
+      blog_header.SetProperty(kBlogPropColumnFamilyName, column_family_name_);
+    }
+    if (blob_compressor_) {
+      blog_header.SetProperty(kBlogPropCompressionCompatibilityName,
+                              blob_compression_manager_->CompatibilityName());
+    }

-  constexpr bool has_ttl = false;
-  constexpr ExpirationRange expiration_range;
+    blog_writer_ =
+        std::make_unique<BlogFileWriter>(std::move(file_writer), blog_header);

-  BlobLogHeader header(column_family_id_, blob_compression_type_, has_ttl,
-                       expiration_range);
-
-  {
-    Status s = blob_log_writer->WriteHeader(*write_options_, header);
+    Status s = blog_writer_->WriteHeader(*write_options_);

    TEST_SYNC_POINT_CALLBACK(
-        "BlobFileBuilder::OpenBlobFileIfNeeded:WriteHeader", &s);
+        "BlobFileBuilder::OpenBlobFileIfNeeded:WriteBlogHeader", &s);

    if (!s.ok()) {
      return s;
    }
-  }
+  } else {
+    // Legacy blob log format path
+    constexpr bool do_flush = false;

-  writer_ = std::move(blob_log_writer);
+    std::unique_ptr<BlobLogWriter> blob_log_writer(
+        new BlobLogWriter(std::move(file_writer), immutable_options_->clock,
+                          statistics, immutable_options_->use_fsync, do_flush));
+
+    constexpr bool has_ttl = false;
+    constexpr ExpirationRange expiration_range;
+
+    BlobLogHeader header(column_family_id_, blob_compression_type_, has_ttl,
+                         expiration_range);
+
+    {
+      Status s = blob_log_writer->WriteHeader(*write_options_, header);
+
+      TEST_SYNC_POINT_CALLBACK(
+          "BlobFileBuilder::OpenBlobFileIfNeeded:WriteHeader", &s);
+
+      if (!s.ok()) {
+        return s;
+      }
+    }
+
+    writer_ = std::move(blob_log_writer);
+  }

  assert(IsBlobFileOpen());

  return Status::OK();
 }

-Status BlobFileBuilder::CompressBlobIfNeeded(
+Status BlobFileBuilder::LegacyCompressBlob(
    Slice* blob, GrowableBuffer* compressed_blob) const {
  assert(blob);
  assert(compressed_blob);
@@ -293,17 +338,48 @@ Status BlobFileBuilder::CompressBlobIfNeeded(
  return Status::OK();
 }

-Status BlobFileBuilder::WriteBlobToFile(const Slice& key, const Slice& blob,
-                                        uint64_t* blob_file_number,
-                                        uint64_t* blob_offset) {
+Status BlobFileBuilder::WriteBlobToFile(
+    const Slice& key, const Slice& blob, uint64_t* blob_file_number,
+    uint64_t* blob_offset, uint64_t* blob_on_disk_size,
+    CompressionType* actual_compression_type) {
  assert(IsBlobFileOpen());
  assert(blob_file_number);
  assert(blob_offset);
+  assert(blob_on_disk_size);
+  assert(actual_compression_type);

-  uint64_t key_offset = 0;
+  Status s;

-  Status s =
-      writer_->AddRecord(*write_options_, key, blob, &key_offset, blob_offset);
+  if (blog_writer_) {
+    // Blog format: compress here using CompressBlock (like SST) so we
+    // capture the actual compression type used in the record trailer.
+    CompressionType actual_type = kNoCompression;
+    GrowableBuffer compressed;
+    if (blob_compressor_) {
+      StopWatch stop_watch(immutable_options_->clock, immutable_options_->stats,
+                           BLOB_DB_COMPRESSION_MICROS);
+      size_t max_compressed_size = blob.size();
+      compressed.ResetForSize(max_compressed_size);
+      s = blob_compressor_->CompressBlock(blob, compressed.data(),
+                                          &compressed.MutableSize(),
+                                          &actual_type, &blob_compressor_wa_);
+      if (!s.ok()) {
+        return s;
+      }
+    }
+    Slice write_data =
+        (actual_type != kNoCompression) ? Slice(compressed) : blob;
+    s = blog_writer_->AddBlobRecord(*write_options_, write_data, actual_type,
+                                    blob_offset);
+    *blob_on_disk_size = write_data.size();
+    *actual_compression_type = actual_type;
+  } else {
+    uint64_t key_offset = 0;
+    s = writer_->AddRecord(*write_options_, key, blob, &key_offset,
+                           blob_offset);
+    *blob_on_disk_size = blob.size();  // legacy: already compressed by caller
+    *actual_compression_type = blob_compression_type_;
+  }

  TEST_SYNC_POINT_CALLBACK("BlobFileBuilder::WriteBlobToFile:AddRecord", &s);

@@ -311,10 +387,16 @@ Status BlobFileBuilder::WriteBlobToFile(const Slice& key, const Slice& blob,
    return s;
  }

-  *blob_file_number = writer_->get_log_number();
+  *blob_file_number = blob_file_number_;

  ++blob_count_;
-  blob_bytes_ += BlobLogRecord::kHeaderSize + key.size() + blob.size();
+  if (blog_writer_) {
+    // Blog format: blob_bytes_ tracks uncompressed payload size only
+    // (no legacy record header, no key).
+    blob_bytes_ += blob.size();
+  } else {
+    blob_bytes_ += BlobLogRecord::kHeaderSize + key.size() + blob.size();
+  }

  return Status::OK();
 }
@@ -322,22 +404,60 @@ Status BlobFileBuilder::WriteBlobToFile(const Slice& key, const Slice& blob,
 Status BlobFileBuilder::CloseBlobFile() {
  assert(IsBlobFileOpen());

-  BlobLogFooter footer;
-  footer.blob_count = blob_count_;
-
  std::string checksum_method;
  std::string checksum_value;
+  Status s;

-  Status s = writer_->AppendFooter(*write_options_, footer, &checksum_method,
-                                   &checksum_value);
+  if (blog_writer_) {
+    // Blog format: write footer properties and locator records.
+    BlogFileFooterProperties footer_props;
+    footer_props.SetBlobCount(blob_count_);
+    footer_props.SetTotalBlobBytes(blob_bytes_);

-  TEST_SYNC_POINT_CALLBACK("BlobFileBuilder::WriteBlobToFile:AppendFooter", &s);
+    uint64_t props_offset = blog_writer_->current_offset();
+    s = blog_writer_->AddFooterPropertiesRecord(*write_options_, footer_props);
+
+    if (s.ok()) {
+      BlogFileFooterLocator locator;
+      uint64_t locator_offset = blog_writer_->current_offset();
+      locator.entries.push_back(
+          {kBlogFooterPropertiesRecord,
+           static_cast<uint32_t>((locator_offset - props_offset) / 4)});
+      s = blog_writer_->AddFooterLocatorRecord(*write_options_, locator);
+    }
+
+    if (s.ok()) {
+      s = blog_writer_->Sync(*write_options_);
+    }
+    if (s.ok()) {
+      s = blog_writer_->Close(*write_options_);
+    }
+    if (s.ok()) {
+      std::string method = blog_writer_->file()->GetFileChecksumFuncName();
+      if (method != kUnknownFileChecksumFuncName) {
+        checksum_method = std::move(method);
+      }
+      std::string value = blog_writer_->file()->GetFileChecksum();
+      if (value != kUnknownFileChecksum) {
+        checksum_value = std::move(value);
+      }
+    }
+  } else {
+    BlobLogFooter footer;
+    footer.blob_count = blob_count_;
+
+    s = writer_->LegacyAppendFooterAndClose(*write_options_, footer,
+                                            &checksum_method, &checksum_value);
+  }
+
+  TEST_SYNC_POINT_CALLBACK(
+      "BlobFileBuilder::WriteBlobToFile:LegacyAppendFooterAndClose", &s);

  if (!s.ok()) {
    return s;
  }

-  const uint64_t blob_file_number = writer_->get_log_number();
+  const uint64_t blob_file_number = blob_file_number_;

  if (blob_callback_) {
    s = blob_callback_->OnBlobFileCompleted(
@@ -359,6 +479,7 @@ Status BlobFileBuilder::CloseBlobFile() {
                 blob_count_, blob_bytes_);

  writer_.reset();
+  blog_writer_.reset();
  blob_count_ = 0;
  blob_bytes_ = 0;

@@ -368,7 +489,8 @@ Status BlobFileBuilder::CloseBlobFile() {
 Status BlobFileBuilder::CloseBlobFileIfNeeded() {
  assert(IsBlobFileOpen());

-  const WritableFileWriter* const file_writer = writer_->file();
+  const WritableFileWriter* const file_writer =
+      blog_writer_ ? blog_writer_->file() : writer_->file();
  assert(file_writer);

  if (file_writer->GetFileSize() < blob_file_size_) {
@@ -387,13 +509,13 @@ void BlobFileBuilder::Abandon(const Status& s) {
    // Blob files. So we can ignore the below error.
    blob_callback_
        ->OnBlobFileCompleted(blob_file_paths_->back(), column_family_name_,
-                              job_id_, writer_->get_log_number(),
-                              creation_reason_, s, "", "", blob_count_,
-                              blob_bytes_)
+                              job_id_, blob_file_number_, creation_reason_, s,
+                              "", "", blob_count_, blob_bytes_)
        .PermitUncheckedError();
  }

  writer_.reset();
+  blog_writer_.reset();
  blob_count_ = 0;
  blob_bytes_ = 0;
 }
@@ -34,6 +34,8 @@ class BlobLogWriter;
 class IOTracer;
 class BlobFileCompletionCallback;

+class BlogFileWriter;
+
 class BlobFileBuilder {
 public:
  BlobFileBuilder(VersionSet* versions, FileSystem* fs,
@@ -78,10 +80,11 @@ class BlobFileBuilder {
 private:
  bool IsBlobFileOpen() const;
  Status OpenBlobFileIfNeeded();
-  Status CompressBlobIfNeeded(Slice* blob,
-                              GrowableBuffer* compressed_blob) const;
+  Status LegacyCompressBlob(Slice* blob, GrowableBuffer* compressed_blob) const;
  Status WriteBlobToFile(const Slice& key, const Slice& blob,
-                         uint64_t* blob_file_number, uint64_t* blob_offset);
+                         uint64_t* blob_file_number, uint64_t* blob_offset,
+                         uint64_t* blob_on_disk_size,
+                         CompressionType* actual_compression_type);
  Status CloseBlobFile();
  Status CloseBlobFileIfNeeded();

@@ -94,6 +97,7 @@ class BlobFileBuilder {
  uint64_t min_blob_size_;
  uint64_t blob_file_size_;
  CompressionType blob_compression_type_;
+  std::shared_ptr<CompressionManager> blob_compression_manager_;
  std::unique_ptr<Compressor> blob_compressor_;
  mutable Compressor::ManagedWorkingArea blob_compressor_wa_;
  PrepopulateBlobCache prepopulate_blob_cache_;
@@ -111,6 +115,8 @@ class BlobFileBuilder {
  std::vector<std::string>* blob_file_paths_;
  std::vector<BlobFileAddition>* blob_file_additions_;
  std::unique_ptr<BlobLogWriter> writer_;
+  std::unique_ptr<BlogFileWriter> blog_writer_;
+  uint64_t blob_file_number_ = 0;
  uint64_t blob_count_;
  uint64_t blob_bytes_;
 };
@@ -598,7 +598,7 @@ INSTANTIATE_TEST_CASE_P(
        "BlobFileBuilder::OpenBlobFileIfNeeded:NewWritableFile",
        "BlobFileBuilder::OpenBlobFileIfNeeded:WriteHeader",
        "BlobFileBuilder::WriteBlobToFile:AddRecord",
-        "BlobFileBuilder::WriteBlobToFile:AppendFooter"}));
+        "BlobFileBuilder::WriteBlobToFile:LegacyAppendFooterAndClose"}));

 TEST_P(BlobFileBuilderIOErrorTest, IOError) {
  // Simulate an I/O error during the specified step of Add()
@@ -123,7 +123,6 @@ Status BlobFileCache::OpenBlobFileReaderUncached(
  Statistics* const statistics = immutable_options_->stats;
  RecordTick(statistics, NO_FILE_OPENS);

-  assert(file_options_);
  Status s = BlobFileReader::Create(
      *immutable_options_, read_options, *file_options_, column_family_id_,
      blob_file_read_hist_, blob_file_number, io_tracer_,
@@ -48,8 +48,7 @@ void WriteBlobFile(uint32_t column_family_id,
  constexpr bool do_flush = false;

  BlobLogWriter blob_log_writer(std::move(file_writer), immutable_options.clock,
-                                statistics, blob_file_number, use_fsync,
-                                do_flush);
+                                statistics, use_fsync, do_flush);

  constexpr bool has_ttl = false;
  constexpr ExpirationRange expiration_range;
@@ -77,8 +76,8 @@ void WriteBlobFile(uint32_t column_family_id,
  std::string checksum_method;
  std::string checksum_value;

-  ASSERT_OK(blob_log_writer.AppendFooter(WriteOptions(), footer,
-                                         &checksum_method, &checksum_value));
+  ASSERT_OK(blob_log_writer.LegacyAppendFooterAndClose(
+      WriteOptions(), footer, &checksum_method, &checksum_value));
 }

 }  // anonymous namespace
@@ -222,8 +221,7 @@ TEST_F(BlobFileCacheTest, RefreshBlobFileReaderPrefersLargestObservedFileSize) {
  constexpr bool use_fsync = false;
  constexpr bool do_flush = false;
  BlobLogWriter blob_log_writer(std::move(file_writer), immutable_options.clock,
-                                statistics, blob_file_number, use_fsync,
-                                do_flush);
+                                statistics, use_fsync, do_flush);

  constexpr bool has_ttl = false;
  constexpr ExpirationRange expiration_range;
@@ -24,7 +24,6 @@
 #include "file/read_write_util.h"
 #include "file/writable_file_writer.h"
 #include "logging/logging.h"
-#include "rocksdb/file_system.h"
 #include "util/aligned_buffer.h"
 #include "util/compression.h"
 #include "util/mutexlock.h"
@@ -200,9 +199,7 @@ Status BlobFilePartitionManager::OpenNewBlobFile(Partition* partition,
  }

  std::unique_ptr<FSWritableFile> file;
-  FileOptions writer_file_options = file_options_;
-  writer_file_options.open_contract = FileOpenContract::kNoReopenForWrite;
-  Status s = NewWritableFile(fs_, blob_file_path, &file, writer_file_options);
+  Status s = NewWritableFile(fs_, blob_file_path, &file, file_options_);
  if (!s.ok()) {
    RemoveFilePartitionMapping(blob_file_number);
    return s;
@@ -211,16 +208,16 @@ Status BlobFilePartitionManager::OpenNewBlobFile(Partition* partition,
  const bool perform_data_verification =
      checksum_handoff_file_types_.Contains(FileType::kBlobFile);
  auto file_writer = std::make_unique<WritableFileWriter>(
-      std::move(file), blob_file_path, writer_file_options, clock_, io_tracer_,
+      std::move(file), blob_file_path, file_options_, clock_, io_tracer_,
      statistics_, Histograms::BLOB_DB_BLOB_FILE_WRITE_MICROS, listeners_,
      file_checksum_gen_factory_, perform_data_verification);

  // This only drains WritableFileWriter's buffered bytes so readers can see
  // each appended record promptly. Durability still comes from SyncAllOpenFiles
-  // or AppendFooter(), both of which call Sync().
+  // or LegacyAppendFooterAndClose(), both of which call Sync().
  constexpr bool kDoFlushEachRecord = true;
  auto blob_log_writer = std::make_unique<BlobLogWriter>(
-      std::move(file_writer), clock_, statistics_, blob_file_number, use_fsync_,
+      std::move(file_writer), clock_, statistics_, use_fsync_,
      kDoFlushEachRecord);

  constexpr bool has_ttl = false;
@@ -303,8 +300,8 @@ Status BlobFilePartitionManager::FinalizeBlobFile(

  std::string checksum_method;
  std::string checksum_value;
-  Status s = writer->AppendFooter(write_options, footer, &checksum_method,
-                                  &checksum_value);
+  Status s = writer->LegacyAppendFooterAndClose(
+      write_options, footer, &checksum_method, &checksum_value);
  if (!s.ok()) {
    return s;
  }
@@ -789,19 +786,13 @@ Status BlobFilePartitionManager::ResolveBlobDirectWriteIndex(
    }
  }

+  Status s = version != nullptr ? Status::Corruption("Invalid blob file number")
+                                : Status::NotFound();
+
  if (blob_file_cache == nullptr) {
-    return version != nullptr ? Status::Corruption("Invalid blob file number")
-                              : Status::NotFound();
+    return s;
  }

-  if (read_options.read_tier == kBlockCacheTier) {
-    // The direct-write fallback below may need to open the blob file reader,
-    // which `kBlockCacheTier` forbids. Keep the normal Version-backed path
-    // above eligible for cache-only hits.
-    return Status::Incomplete("Cannot read blob(s): no disk I/O allowed");
-  }
-
-  Status s;
  CacheHandleGuard<BlobFileReader> reader;
  s = blob_file_cache->GetBlobFileReader(read_options, blob_idx.file_number(),
                                         &reader,
@@ -5,14 +5,16 @@

 #include "db/blob/blob_file_reader.h"

+#include <algorithm>
 #include <cassert>
+#include <cstring>
 #include <string>

 #include "db/blob/blob_contents.h"
 #include "db/blob/blob_log_format.h"
+#include "db/blog/blog_format.h"
 #include "file/file_prefetch_buffer.h"
 #include "file/filename.h"
-#include "file/read_write_util.h"
 #include "monitoring/statistics_impl.h"
 #include "options/cf_options.h"
 #include "rocksdb/file_system.h"
@@ -21,7 +23,6 @@
 #include "table/format.h"
 #include "table/multiget_context.h"
 #include "test_util/sync_point.h"
-#include "util/aligned_buffer.h"
 #include "util/compression.h"
 #include "util/stop_watch.h"

@@ -53,37 +54,30 @@ Status BlobFileReader::Create(

  Statistics* const statistics = immutable_options.stats;

-  CompressionType compression_type = kNoCompression;
+  // Construct with defaults; ReadHeader will detect blog vs legacy format
+  // and populate the appropriate fields.
+  blob_file_reader->reset(
+      new BlobFileReader(std::move(file_reader), file_size, kNoCompression,
+                         /*decompressor=*/nullptr, immutable_options.clock,
+                         statistics, /*has_footer=*/false));

  {
    const Status s =
-        ReadHeader(file_reader.get(), read_options, column_family_id,
-                   statistics, &compression_type);
+        (*blob_file_reader)->ReadHeader(read_options, column_family_id);
    if (!s.ok()) {
+      blob_file_reader->reset();
      return s;
    }
  }

  if (!skip_footer_validation) {
-    const Status s =
-        ReadFooter(file_reader.get(), read_options, file_size, statistics);
+    const Status s = (*blob_file_reader)->ReadFooter(read_options);
    if (!s.ok()) {
+      blob_file_reader->reset();
      return s;
    }
  }

-  std::shared_ptr<Decompressor> decompressor;
-  if (compression_type != kNoCompression) {
-    // The blob format has always used compression format 2
-    decompressor = GetBuiltinV2CompressionManager()->GetDecompressorOptimizeFor(
-        compression_type);
-  }
-
-  blob_file_reader->reset(
-      new BlobFileReader(std::move(file_reader), file_size, compression_type,
-                         std::move(decompressor), immutable_options.clock,
-                         statistics, !skip_footer_validation));
-
  return Status::OK();
 }

@@ -107,6 +101,24 @@ Status BlobFileReader::OpenFile(

  constexpr IODebugContext* dbg = nullptr;

+  {
+    TEST_SYNC_POINT("BlobFileReader::OpenFile:GetFileSize");
+
+    const Status s =
+        fs->GetFileSize(blob_file_path, IOOptions(), file_size, dbg);
+    if (!s.ok()) {
+      return s;
+    }
+  }
+
+  if (!skip_footer_size_check &&
+      *file_size < BlobLogHeader::kSize + BlobLogFooter::kSize) {
+    return Status::Corruption("Malformed blob file");
+  }
+  if (skip_footer_size_check && *file_size < BlobLogHeader::kSize) {
+    return Status::Corruption("Malformed blob file");
+  }
+
  std::unique_ptr<FSRandomAccessFile> file;
  FileOptions reader_file_opts = file_opts;

@@ -126,24 +138,6 @@ Status BlobFileReader::OpenFile(

  assert(file);

-  {
-    Status s = GetFileSizeFromOpenFileOrPath(
-        file.get(), fs, blob_file_path, file_size, dbg,
-        FileSizeFallback::kNotSupportedOnly,
-        []() { TEST_SYNC_POINT("BlobFileReader::OpenFile:GetFileSize"); });
-    if (!s.ok()) {
-      return s;
-    }
-  }
-
-  if (!skip_footer_size_check &&
-      *file_size < BlobLogHeader::kSize + BlobLogFooter::kSize) {
-    return Status::Corruption("Malformed blob file");
-  }
-  if (skip_footer_size_check && *file_size < BlobLogHeader::kSize) {
-    return Status::Corruption("Malformed blob file");
-  }
-
  if (immutable_options.advise_random_on_open) {
    file->Hint(FSRandomAccessFile::kRandom);
  }
@@ -157,27 +151,28 @@ Status BlobFileReader::OpenFile(
  return Status::OK();
 }

-Status BlobFileReader::ReadHeader(const RandomAccessFileReader* file_reader,
-                                  const ReadOptions& read_options,
-                                  uint32_t column_family_id,
-                                  Statistics* statistics,
-                                  CompressionType* compression_type) {
-  assert(file_reader);
-  assert(compression_type);
+Status BlobFileReader::ReadHeader(const ReadOptions& read_options,
+                                  uint32_t column_family_id) {
+  assert(file_reader_);
+
+  // Read ~4 KiB from the start to cover both legacy (30B) and blog (40B
+  // fixed + property section) headers in a single I/O. This is enough for
+  // typical blog headers; only if the property section exceeds ~4 KiB do
+  // we need a second read.
+  constexpr size_t kInitialReadSize = 4096;
+  const size_t read_size =
+      std::min(static_cast<uint64_t>(kInitialReadSize), file_size_);

  Slice header_slice;
  Buffer buf;
-  AlignedBuffer direct_io_buffer;
+  AlignedBuf aligned_buf;

  {
    TEST_SYNC_POINT("BlobFileReader::ReadHeader:ReadFromFile");

-    constexpr uint64_t read_offset = 0;
-    constexpr size_t read_size = BlobLogHeader::kSize;
-
    const Status s =
-        ReadFromFile(file_reader, read_options, read_offset, read_size,
-                     statistics, &header_slice, &buf, &direct_io_buffer);
+        ReadFromFile(file_reader_.get(), read_options, 0, read_size,
+                     statistics_, &header_slice, &buf, &aligned_buf);
    if (!s.ok()) {
      return s;
    }
@@ -186,10 +181,58 @@ Status BlobFileReader::ReadHeader(const RandomAccessFileReader* file_reader,
                             &header_slice);
  }

+  // Detect blog format by checking the 12-byte magic.
+  if (BlogFileHeader::IsBlogFormat(header_slice.data(), header_slice.size())) {
+    // Try to decode the blog header from the buffer we already read.
+    // DecodeFromBuffer handles the case where the property section
+    // extends beyond the buffer.
+    BlogFileHeader blog_header;
+    Slice buf_slice = header_slice;
+    size_t additional_needed = 0;
+    Status s = blog_header.DecodeFromBuffer(&buf_slice, &additional_needed);
+
+    if (s.IsIncomplete()) {
+      // Need more data. Read the rest and retry.
+      Slice extra_slice;
+      Buffer extra_buf;
+      AlignedBuf extra_aligned;
+      s = ReadFromFile(file_reader_.get(), read_options, header_slice.size(),
+                       additional_needed, statistics_, &extra_slice, &extra_buf,
+                       &extra_aligned);
+      if (!s.ok()) {
+        return s;
+      }
+      std::string extended;
+      extended.append(header_slice.data(), header_slice.size());
+      extended.append(extra_slice.data(), extra_slice.size());
+      Slice extended_slice(extended);
+      s = blog_header.DecodeFromBuffer(&extended_slice, nullptr);
+    }
+
+    if (!s.ok()) {
+      return s;
+    }
+
+    is_blog_format_ = true;
+    blog_checksum_type_ = blog_header.checksum_type;
+    blog_incarnation_id_ = blog_header.incarnation_id();
+    memcpy(blog_escape_sequence_, blog_header.escape_sequence,
+           kBlogEscapeSequenceSize);
+    compression_type_ = kNoCompression;
+    decompressor_ = GetBuiltinV2CompressionManager()->GetDecompressor();
+    return Status::OK();
+  }
+
+  // Legacy blob format. The initial read already covers the 30-byte header.
+  if (header_slice.size() < BlobLogHeader::kSize) {
+    return Status::Corruption("Blob file header too small");
+  }
+
+  Slice legacy_slice(header_slice.data(), BlobLogHeader::kSize);
  BlobLogHeader header;

  {
-    const Status s = header.DecodeFrom(header_slice);
+    const Status s = header.DecodeFrom(legacy_slice);
    if (!s.ok()) {
      return s;
    }
@@ -205,30 +248,76 @@ Status BlobFileReader::ReadHeader(const RandomAccessFileReader* file_reader,
    return Status::Corruption("Column family ID mismatch");
  }

-  *compression_type = header.compression;
+  compression_type_ = header.compression;
+  if (compression_type_ != kNoCompression) {
+    decompressor_ =
+        GetBuiltinV2CompressionManager()->GetDecompressorOptimizeFor(
+            compression_type_);
+  }

  return Status::OK();
 }

-Status BlobFileReader::ReadFooter(const RandomAccessFileReader* file_reader,
-                                  const ReadOptions& read_options,
-                                  uint64_t file_size, Statistics* statistics) {
-  assert(file_size >= BlobLogHeader::kSize + BlobLogFooter::kSize);
-  assert(file_reader);
+Status BlobFileReader::ReadFooter(const ReadOptions& read_options) {
+  assert(file_reader_);
+
+  if (is_blog_format_) {
+    // Blog format: verify the file was cleanly sealed by scanning backward
+    // from EOF for the last record's escape sequence. Read the trailing
+    // ~4 KiB in a single I/O and scan within the buffer.
+    if (file_size_ < kBlogFileFixedHeaderSize + kBlogEscapeSequenceSize) {
+      return Status::Corruption("Blog blob file too small for footer");
+    }
+
+    constexpr size_t kTrailingReadSize = 4096;
+    const uint64_t min_offset = kBlogFileFixedHeaderSize;
+    // Round trailing_offset up to 4-byte alignment so buffer positions
+    // and file positions share the same alignment grid.
+    const uint64_t trailing_offset =
+        (file_size_ -
+         std::min(static_cast<uint64_t>(kTrailingReadSize),
+                  file_size_ - min_offset) +
+         3) &
+        ~uint64_t{3};
+    const size_t trailing_size =
+        static_cast<size_t>(file_size_ - trailing_offset);
+
+    Slice trailing_slice;
+    Buffer trailing_buf;
+    AlignedBuf trailing_aligned;
+    Status s = ReadFromFile(file_reader_.get(), read_options, trailing_offset,
+                            trailing_size, statistics_, &trailing_slice,
+                            &trailing_buf, &trailing_aligned);
+    if (!s.ok()) {
+      return s;
+    }
+
+    if (VerifyBlogFooterLocator(trailing_slice.data(), trailing_size,
+                                trailing_offset, blog_escape_sequence_,
+                                blog_checksum_type_, blog_incarnation_id_)) {
+      has_footer_ = true;
+      return Status::OK();
+    }
+
+    return Status::Corruption("Blog blob file: no footer locator record found");
+  }
+
+  // Legacy blob format.
+  assert(file_size_ >= BlobLogHeader::kSize + BlobLogFooter::kSize);

  Slice footer_slice;
  Buffer buf;
-  AlignedBuffer direct_io_buffer;
+  AlignedBuf aligned_buf;

  {
    TEST_SYNC_POINT("BlobFileReader::ReadFooter:ReadFromFile");

-    const uint64_t read_offset = file_size - BlobLogFooter::kSize;
+    const uint64_t read_offset = file_size_ - BlobLogFooter::kSize;
    constexpr size_t read_size = BlobLogFooter::kSize;

    const Status s =
-        ReadFromFile(file_reader, read_options, read_offset, read_size,
-                     statistics, &footer_slice, &buf, &direct_io_buffer);
+        ReadFromFile(file_reader_.get(), read_options, read_offset, read_size,
+                     statistics_, &footer_slice, &buf, &aligned_buf);
    if (!s.ok()) {
      return s;
    }
@@ -252,6 +341,7 @@ Status BlobFileReader::ReadFooter(const RandomAccessFileReader* file_reader,
    return Status::Corruption("Unexpected TTL blob file");
  }

+  has_footer_ = true;
  return Status::OK();
 }

@@ -259,11 +349,10 @@ Status BlobFileReader::ReadFromFile(const RandomAccessFileReader* file_reader,
                                    const ReadOptions& read_options,
                                    uint64_t read_offset, size_t read_size,
                                    Statistics* statistics, Slice* slice,
-                                    Buffer* buf,
-                                    AlignedBuffer* direct_io_buffer) {
+                                    Buffer* buf, AlignedBuf* aligned_buf) {
  assert(slice);
  assert(buf);
-  assert(direct_io_buffer);
+  assert(aligned_buf);

  assert(file_reader);

@@ -280,15 +369,15 @@ Status BlobFileReader::ReadFromFile(const RandomAccessFileReader* file_reader,

  if (file_reader->use_direct_io()) {
    constexpr char* scratch = nullptr;
-    AlignedBufferAllocationContext direct_io_context{direct_io_buffer};

    s = file_reader->Read(io_options, read_offset, read_size, slice, scratch,
-                          &direct_io_context, &dbg);
+                          aligned_buf, &dbg);
  } else {
    buf->reset(new char[read_size]);
+    constexpr AlignedBuf* aligned_scratch = nullptr;

    s = file_reader->Read(io_options, read_offset, read_size, slice, buf->get(),
-                          nullptr, &dbg);
+                          aligned_scratch, &dbg);
  }

  if (!s.ok()) {
@@ -326,33 +415,43 @@ Status BlobFileReader::GetBlob(
    std::unique_ptr<BlobContents>* result, uint64_t* bytes_read) const {
  assert(result);

-  const uint64_t key_size = user_key.size();
+  // Compute the read region. Both formats store the blob value at `offset`
+  // with size `value_size`. The difference:
+  // - Legacy: if verifying checksums, also read the record header (before
+  //   the value) which contains key + CRC.
+  // - Blog: if verifying checksums, also read the 5-byte trailer (after
+  //   the value) which contains compression_type + checksum.
+  uint64_t adjustment_before = 0;  // bytes before the value to include
+  uint64_t adjustment_after = 0;   // bytes after the value to include

-  if (!IsValidBlobOffset(offset, key_size, value_size, file_size_,
-                         has_footer_)) {
-    return Status::Corruption("Invalid blob offset");
+  if (is_blog_format_) {
+    if (read_options.verify_checksums) {
+      adjustment_after = kBlogBlockTrailerSize;
+    }
+  } else {
+    const uint64_t key_size = user_key.size();
+    if (!IsValidBlobOffset(offset, key_size, value_size, file_size_,
+                           has_footer_)) {
+      return Status::Corruption("Invalid blob offset");
+    }
+    if (compression_type != compression_type_) {
+      return Status::Corruption("Compression type mismatch when reading blob");
+    }
+    if (read_options.verify_checksums) {
+      adjustment_before =
+          BlobLogRecord::CalculateAdjustmentForRecordHeader(key_size);
+    }
  }

-  if (compression_type != compression_type_) {
-    return Status::Corruption("Compression type mismatch when reading blob");
-  }
-
-  // Note: if verify_checksum is set, we read the entire blob record to be able
-  // to perform the verification; otherwise, we just read the blob itself. Since
-  // the offset in BlobIndex actually points to the blob value, we need to make
-  // an adjustment in the former case.
-  const uint64_t adjustment =
-      read_options.verify_checksums
-          ? BlobLogRecord::CalculateAdjustmentForRecordHeader(key_size)
-          : 0;
-  assert(offset >= adjustment);
-
-  const uint64_t record_offset = offset - adjustment;
-  const uint64_t record_size = value_size + adjustment;
+  assert(offset >= adjustment_before);
+  const uint64_t record_offset = offset - adjustment_before;
+  const uint64_t record_size =
+      adjustment_before + value_size + adjustment_after;

+  // Read the data: try prefetch buffer first, then fall back to file read.
  Slice record_slice;
  Buffer buf;
-  AlignedBuffer direct_io_buffer;
+  AlignedBuf aligned_buf;

  bool prefetched = false;

@@ -382,7 +481,7 @@ Status BlobFileReader::GetBlob(
    const Status s =
        ReadFromFile(file_reader_.get(), read_options, record_offset,
                     static_cast<size_t>(record_size), statistics_,
-                     &record_slice, &buf, &direct_io_buffer);
+                     &record_slice, &buf, &aligned_buf);
    if (!s.ok()) {
      return s;
    }
@@ -391,17 +490,30 @@ Status BlobFileReader::GetBlob(
  TEST_SYNC_POINT_CALLBACK("BlobFileReader::GetBlob:TamperWithResult",
                           &record_slice);

+  // Verify checksum (format-specific).
+  CompressionType actual_comp_type = compression_type;
  if (read_options.verify_checksums) {
-    const Status s = VerifyBlob(record_slice, user_key, value_size);
-    if (!s.ok()) {
-      return s;
+    if (is_blog_format_) {
+      const Status s = VerifyBlogRecordTrailer(
+          blog_checksum_type_, record_slice.data(),
+          static_cast<size_t>(value_size), blog_incarnation_id_, offset,
+          &actual_comp_type);
+      if (!s.ok()) {
+        return s;
+      }
+    } else {
+      const Status s = VerifyBlob(record_slice, user_key, value_size);
+      if (!s.ok()) {
+        return s;
+      }
    }
  }

-  const Slice value_slice(record_slice.data() + adjustment, value_size);
+  // Extract the value slice (format-specific offset within the read region).
+  const Slice value_slice(record_slice.data() + adjustment_before, value_size);

  {
-    const Status s = UncompressBlobIfNeeded(value_slice, compression_type,
+    const Status s = UncompressBlobIfNeeded(value_slice, actual_comp_type,
                                            decompressor_.get(), allocator,
                                            clock_, statistics_, result);
    if (!s.ok()) {
@@ -480,7 +592,7 @@ void BlobFileReader::MultiGetBlob(
  }

  Buffer buf;
-  AlignedBuffer direct_io_buffer;
+  AlignedBuf aligned_buf;

  Status s;
  bool direct_io = file_reader_->use_direct_io();
@@ -503,9 +615,8 @@ void BlobFileReader::MultiGetBlob(
  IODebugContext dbg;
  s = file_reader_->PrepareIOOptions(read_options, opts, &dbg);
  if (s.ok()) {
-    AlignedBufferAllocationContext direct_io_context{&direct_io_buffer};
    s = file_reader_->MultiRead(opts, read_reqs.data(), read_reqs.size(),
-                                &direct_io_context, &dbg);
+                                direct_io ? &aligned_buf : nullptr, &dbg);
  }
  if (!s.ok()) {
    for (auto& req : read_reqs) {
@@ -93,14 +93,15 @@ class BlobFileReader {
                         std::unique_ptr<RandomAccessFileReader>* file_reader,
                         bool skip_footer_size_check);

-  static Status ReadHeader(const RandomAccessFileReader* file_reader,
-                           const ReadOptions& read_options,
-                           uint32_t column_family_id, Statistics* statistics,
-                           CompressionType* compression_type);
+  // Read and validate the file header. Detects blog format vs legacy format,
+  // setting is_blog_format_ and related fields accordingly. For legacy format,
+  // validates column_family_id and sets compression_type_.
+  Status ReadHeader(const ReadOptions& read_options, uint32_t column_family_id);

-  static Status ReadFooter(const RandomAccessFileReader* file_reader,
-                           const ReadOptions& read_options, uint64_t file_size,
-                           Statistics* statistics);
+  // Validate the file footer. For legacy format, reads and validates the
+  // BlobLogFooter. For blog format, scans backward for the footer locator
+  // record to verify the file was cleanly sealed.
+  Status ReadFooter(const ReadOptions& read_options);

  using Buffer = std::unique_ptr<char[]>;

@@ -108,7 +109,7 @@ class BlobFileReader {
                             const ReadOptions& read_options,
                             uint64_t read_offset, size_t read_size,
                             Statistics* statistics, Slice* slice, Buffer* buf,
-                             AlignedBuffer* direct_io_buffer);
+                             AlignedBuf* aligned_buf);

  static Status VerifyBlob(const Slice& record_slice, const Slice& user_key,
                           uint64_t value_size);
@@ -129,6 +130,13 @@ class BlobFileReader {
  Statistics* statistics_;
  // False when the reader was opened before the blob file footer was written.
  bool has_footer_;
+  // True when the file uses blog format instead of legacy blob log format.
+  bool is_blog_format_ = false;
+  // For blog format: fields from the file header used for record checksum
+  // verification and footer validation.
+  uint32_t blog_incarnation_id_ = 0;
+  ChecksumType blog_checksum_type_ = kNoChecksum;
+  char blog_escape_sequence_[10] = {};  // kBlogEscapeSequenceSize
 };

 }  // namespace ROCKSDB_NAMESPACE
@@ -7,12 +7,10 @@

 #include <cassert>
 #include <string>
-#include <utility>

 #include "db/blob/blob_contents.h"
 #include "db/blob/blob_log_format.h"
 #include "db/blob/blob_log_writer.h"
-#include "env/composite_env_wrapper.h"
 #include "env/mock_env.h"
 #include "file/filename.h"
 #include "file/read_write_util.h"
@@ -59,8 +57,7 @@ void WriteBlobFile(const ImmutableOptions& immutable_options,
  constexpr bool do_flush = false;

  BlobLogWriter blob_log_writer(std::move(file_writer), immutable_options.clock,
-                                statistics, blob_file_number, use_fsync,
-                                do_flush);
+                                statistics, use_fsync, do_flush);

  BlobLogHeader header(column_family_id, compression, has_ttl,
                       expiration_range_header);
@@ -100,8 +97,8 @@ void WriteBlobFile(const ImmutableOptions& immutable_options,

  std::string checksum_method;
  std::string checksum_value;
-  ASSERT_OK(blob_log_writer.AppendFooter(WriteOptions(), footer,
-                                         &checksum_method, &checksum_value));
+  ASSERT_OK(blob_log_writer.LegacyAppendFooterAndClose(
+      WriteOptions(), footer, &checksum_method, &checksum_value));
 }

 // Creates a test blob file with a single blob in it. Note: this method
@@ -138,167 +135,6 @@ class BlobFileReaderTest : public testing::Test {
  std::unique_ptr<Env> mock_env_;
 };

-namespace {
-
-// Returns a stale path-level size for one target blob file while leaving the
-// opened file handle untouched. This lets the test verify
-// BlobFileReader::Create prefers the opened handle's size when the path stat
-// lags behind.
-class StalePathSizeFileSystem : public FileSystemWrapper {
- public:
-  static const char* kClassName() { return "StalePathSizeFileSystem"; }
-
-  StalePathSizeFileSystem(const std::shared_ptr<FileSystem>& target,
-                          std::string stale_path)
-      : FileSystemWrapper(target), stale_path_(std::move(stale_path)) {}
-
-  const char* Name() const override { return kClassName(); }
-
-  IOStatus GetFileSize(const std::string& fname, const IOOptions& options,
-                       uint64_t* file_size, IODebugContext* dbg) override {
-    if (fname == stale_path_) {
-      *file_size = 0;
-      return IOStatus::OK();
-    }
-    return FileSystemWrapper::GetFileSize(fname, options, file_size, dbg);
-  }
-
- private:
-  const std::string stale_path_;
-};
-
-// Makes opened blob file handles fail GetFileSize() with a hard error so the
-// reader path can verify that such errors are propagated directly.
-class FailingOpenFileSizeRandomAccessFile
-    : public FSRandomAccessFileOwnerWrapper {
- public:
-  explicit FailingOpenFileSizeRandomAccessFile(
-      std::unique_ptr<FSRandomAccessFile>&& target)
-      : FSRandomAccessFileOwnerWrapper(std::move(target)) {}
-
-  IOStatus GetFileSize(uint64_t* /*result*/) override {
-    return IOStatus::IOError("open file size failed");
-  }
-};
-
-// Makes opened blob file handles report GetFileSize() as unsupported so the
-// reader path exercises its path-level fallback logic.
-class NotSupportedOpenFileSizeRandomAccessFile
-    : public FSRandomAccessFileOwnerWrapper {
- public:
-  explicit NotSupportedOpenFileSizeRandomAccessFile(
-      std::unique_ptr<FSRandomAccessFile>&& target)
-      : FSRandomAccessFileOwnerWrapper(std::move(target)) {}
-
-  IOStatus GetFileSize(uint64_t* /*result*/) override {
-    return IOStatus::NotSupported("open file size not supported");
-  }
-};
-
-class OpenFileSizeFileSystem : public FileSystemWrapper {
- public:
-  OpenFileSizeFileSystem(const std::shared_ptr<FileSystem>& target,
-                         std::string target_path)
-      : FileSystemWrapper(target), target_path_(std::move(target_path)) {}
-
-  IOStatus NewRandomAccessFile(const std::string& fname,
-                               const FileOptions& options,
-                               std::unique_ptr<FSRandomAccessFile>* result,
-                               IODebugContext* dbg) override {
-    std::unique_ptr<FSRandomAccessFile> file;
-    IOStatus s =
-        FileSystemWrapper::NewRandomAccessFile(fname, options, &file, dbg);
-    if (!s.ok()) {
-      return IOStatus(std::move(s));
-    }
-    if (fname == target_path_) {
-      *result = WrapTargetFile(std::move(file));
-    } else {
-      *result = std::move(file);
-    }
-    return IOStatus::OK();
-  }
-
- protected:
-  virtual std::unique_ptr<FSRandomAccessFile> WrapTargetFile(
-      std::unique_ptr<FSRandomAccessFile>&& file) = 0;
-
- private:
-  const std::string target_path_;
-};
-
-// Wraps the target blob file in FailingOpenFileSizeRandomAccessFile while
-// leaving all other files alone.
-class FailingOpenFileSizeFileSystem : public OpenFileSizeFileSystem {
- public:
-  static const char* kClassName() { return "FailingOpenFileSizeFileSystem"; }
-
-  FailingOpenFileSizeFileSystem(const std::shared_ptr<FileSystem>& target,
-                                std::string target_path)
-      : OpenFileSizeFileSystem(target, std::move(target_path)) {}
-
-  const char* Name() const override { return kClassName(); }
-
- private:
-  std::unique_ptr<FSRandomAccessFile> WrapTargetFile(
-      std::unique_ptr<FSRandomAccessFile>&& file) override {
-    return std::unique_ptr<FSRandomAccessFile>(
-        new FailingOpenFileSizeRandomAccessFile(std::move(file)));
-  }
-};
-
-// Wraps the target blob file in NotSupportedOpenFileSizeRandomAccessFile while
-// leaving all other files alone.
-class NotSupportedOpenFileSizeFileSystem : public OpenFileSizeFileSystem {
- public:
-  static const char* kClassName() {
-    return "NotSupportedOpenFileSizeFileSystem";
-  }
-
-  NotSupportedOpenFileSizeFileSystem(const std::shared_ptr<FileSystem>& target,
-                                     std::string target_path)
-      : OpenFileSizeFileSystem(target, std::move(target_path)) {}
-
-  const char* Name() const override { return kClassName(); }
-
- private:
-  std::unique_ptr<FSRandomAccessFile> WrapTargetFile(
-      std::unique_ptr<FSRandomAccessFile>&& file) override {
-    return std::unique_ptr<FSRandomAccessFile>(
-        new NotSupportedOpenFileSizeRandomAccessFile(std::move(file)));
-  }
-};
-
-// Forces the target blob file onto the NotSupported open-handle-size branch and
-// then fails the fallback path-level GetFileSize() call.
-class FailingFallbackPathSizeFileSystem
-    : public NotSupportedOpenFileSizeFileSystem {
- public:
-  static const char* kClassName() {
-    return "FailingFallbackPathSizeFileSystem";
-  }
-
-  FailingFallbackPathSizeFileSystem(const std::shared_ptr<FileSystem>& target,
-                                    std::string target_path)
-      : NotSupportedOpenFileSizeFileSystem(target, target_path),
-        target_path_(std::move(target_path)) {}
-
-  const char* Name() const override { return kClassName(); }
-
-  IOStatus GetFileSize(const std::string& fname, const IOOptions& options,
-                       uint64_t* file_size, IODebugContext* dbg) override {
-    if (fname == target_path_) {
-      return IOStatus::IOError("fallback path size failed");
-    }
-    return FileSystemWrapper::GetFileSize(fname, options, file_size, dbg);
-  }
-
- private:
-  const std::string target_path_;
-};
-
-}  // namespace
-
 TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
  Options options;
  options.env = mock_env_.get();
@@ -591,211 +427,6 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
  }
 }

-// Verifies Create() prefers the file size reported by the opened handle over a
-// stale path-level size query by returning a readable reader even when the path
-// stat intentionally reports 0 for the blob file.
-TEST_F(BlobFileReaderTest, CreateReaderUsesOpenedFileSizeWhenPathSizeIsStale) {
-  const std::string db_path = test::PerThreadDBPath(
-      mock_env_.get(),
-      "BlobFileReaderTest_CreateReaderUsesOpenedFileSizeWhenPathSizeIsStale");
-
-  constexpr uint64_t blob_file_number = 1;
-  const std::string blob_file_path = BlobFileName(db_path, blob_file_number);
-
-  auto stale_size_fs = std::make_shared<StalePathSizeFileSystem>(
-      mock_env_->GetFileSystem(), blob_file_path);
-  CompositeEnvWrapper stale_size_env(mock_env_.get(), stale_size_fs);
-
-  Options options;
-  options.env = &stale_size_env;
-  options.cf_paths.emplace_back(db_path, 0);
-  options.enable_blob_files = true;
-
-  ImmutableOptions immutable_options(options);
-
-  constexpr uint32_t column_family_id = 1;
-  constexpr bool has_ttl = false;
-  constexpr ExpirationRange expiration_range;
-  constexpr char key[] = "key";
-  constexpr char blob[] = "blob";
-
-  uint64_t blob_offset = 0;
-  uint64_t blob_size = 0;
-  WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range,
-                expiration_range, blob_file_number, key, blob, kNoCompression,
-                &blob_offset, &blob_size);
-
-  std::unique_ptr<BlobFileReader> reader;
-  ReadOptions read_options;
-  read_options.verify_checksums = false;
-  ASSERT_OK(BlobFileReader::Create(
-      immutable_options, read_options, FileOptions(), column_family_id,
-      /*blob_file_read_hist=*/nullptr, blob_file_number, nullptr /*IOTracer*/,
-      &reader));
-  ASSERT_NE(reader, nullptr);
-
-  std::unique_ptr<BlobContents> value;
-  uint64_t bytes_read = 0;
-  ASSERT_OK(reader->GetBlob(read_options, key, blob_offset, blob_size,
-                            kNoCompression,
-                            /*prefetch_buffer=*/nullptr,
-                            /*allocator=*/nullptr, &value, &bytes_read));
-  ASSERT_NE(value, nullptr);
-  ASSERT_EQ(value->data(), Slice(blob));
-  ASSERT_EQ(bytes_read, blob_size);
-}
-
-// Verifies Create() falls back to the path-level GetFileSize() call when the
-// opened file handle reports that size queries are unsupported.
-TEST_F(BlobFileReaderTest,
-       CreateReaderFallsBackToPathSizeWhenOpenedFileSizeNotSupported) {
-  const std::string db_path = test::PerThreadDBPath(
-      mock_env_.get(),
-      "BlobFileReaderTest_"
-      "CreateReaderFallsBackToPathSizeWhenOpenedFileSizeNotSupported");
-
-  constexpr uint64_t blob_file_number = 1;
-  const std::string blob_file_path = BlobFileName(db_path, blob_file_number);
-
-  auto not_supported_open_file_size_fs =
-      std::make_shared<NotSupportedOpenFileSizeFileSystem>(
-          mock_env_->GetFileSystem(), blob_file_path);
-  CompositeEnvWrapper not_supported_open_file_size_env(
-      mock_env_.get(), not_supported_open_file_size_fs);
-
-  Options options;
-  options.env = &not_supported_open_file_size_env;
-  options.cf_paths.emplace_back(db_path, 0);
-  options.enable_blob_files = true;
-
-  ImmutableOptions immutable_options(options);
-
-  constexpr uint32_t column_family_id = 1;
-  constexpr bool has_ttl = false;
-  constexpr ExpirationRange expiration_range;
-  constexpr char key[] = "key";
-  constexpr char blob[] = "blob";
-
-  uint64_t blob_offset = 0;
-  uint64_t blob_size = 0;
-  WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range,
-                expiration_range, blob_file_number, key, blob, kNoCompression,
-                &blob_offset, &blob_size);
-
-  std::unique_ptr<BlobFileReader> reader;
-  ReadOptions read_options;
-  read_options.verify_checksums = false;
-  ASSERT_OK(BlobFileReader::Create(
-      immutable_options, read_options, FileOptions(), column_family_id,
-      /*blob_file_read_hist=*/nullptr, blob_file_number, nullptr /*IOTracer*/,
-      &reader));
-  ASSERT_NE(reader, nullptr);
-
-  std::unique_ptr<BlobContents> value;
-  uint64_t bytes_read = 0;
-  ASSERT_OK(reader->GetBlob(read_options, key, blob_offset, blob_size,
-                            kNoCompression,
-                            /*prefetch_buffer=*/nullptr,
-                            /*allocator=*/nullptr, &value, &bytes_read));
-  ASSERT_NE(value, nullptr);
-  ASSERT_EQ(value->data(), Slice(blob));
-  ASSERT_EQ(bytes_read, blob_size);
-}
-
-// Verifies Create() propagates a real error from the opened file handle's
-// GetFileSize() rather than masking it with any path-level fallback.
-TEST_F(BlobFileReaderTest, CreateReaderPropagatesOpenedFileSizeError) {
-  const std::string db_path = test::PerThreadDBPath(
-      mock_env_.get(),
-      "BlobFileReaderTest_CreateReaderPropagatesOpenedFileSizeError");
-
-  constexpr uint64_t blob_file_number = 1;
-  const std::string blob_file_path = BlobFileName(db_path, blob_file_number);
-
-  auto failing_open_file_size_fs =
-      std::make_shared<FailingOpenFileSizeFileSystem>(
-          mock_env_->GetFileSystem(), blob_file_path);
-  CompositeEnvWrapper failing_open_file_size_env(mock_env_.get(),
-                                                 failing_open_file_size_fs);
-
-  Options options;
-  options.env = &failing_open_file_size_env;
-  options.cf_paths.emplace_back(db_path, 0);
-  options.enable_blob_files = true;
-
-  ImmutableOptions immutable_options(options);
-
-  constexpr uint32_t column_family_id = 1;
-  constexpr bool has_ttl = false;
-  constexpr ExpirationRange expiration_range;
-  constexpr char key[] = "key";
-  constexpr char blob[] = "blob";
-
-  uint64_t blob_offset = 0;
-  uint64_t blob_size = 0;
-  WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range,
-                expiration_range, blob_file_number, key, blob, kNoCompression,
-                &blob_offset, &blob_size);
-
-  std::unique_ptr<BlobFileReader> reader;
-  ReadOptions read_options;
-  Status s = BlobFileReader::Create(
-      immutable_options, read_options, FileOptions(), column_family_id,
-      /*blob_file_read_hist=*/nullptr, blob_file_number, nullptr /*IOTracer*/,
-      &reader);
-  ASSERT_TRUE(s.IsIOError());
-  ASSERT_EQ(reader, nullptr);
-}
-
-// Verifies Create() also propagates errors from the path-level fallback size
-// query when the opened file handle only reports NotSupported for GetFileSize.
-TEST_F(
-    BlobFileReaderTest,
-    CreateReaderPropagatesFallbackPathSizeErrorWhenOpenedFileSizeNotSupported) {
-  const std::string db_path =
-      test::PerThreadDBPath(mock_env_.get(),
-                            "BlobFileReaderTest_"
-                            "CreateReaderPropagatesFallbackPathSizeErrorWhenOpe"
-                            "nedFileSizeNotSupported");
-
-  constexpr uint64_t blob_file_number = 1;
-  const std::string blob_file_path = BlobFileName(db_path, blob_file_number);
-
-  auto failing_fallback_path_size_fs =
-      std::make_shared<FailingFallbackPathSizeFileSystem>(
-          mock_env_->GetFileSystem(), blob_file_path);
-  CompositeEnvWrapper failing_fallback_path_size_env(
-      mock_env_.get(), failing_fallback_path_size_fs);
-
-  Options options;
-  options.env = &failing_fallback_path_size_env;
-  options.cf_paths.emplace_back(db_path, 0);
-  options.enable_blob_files = true;
-
-  ImmutableOptions immutable_options(options);
-
-  constexpr uint32_t column_family_id = 1;
-  constexpr bool has_ttl = false;
-  constexpr ExpirationRange expiration_range;
-  constexpr char key[] = "key";
-  constexpr char blob[] = "blob";
-
-  uint64_t blob_offset = 0;
-  uint64_t blob_size = 0;
-  WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range,
-                expiration_range, blob_file_number, key, blob, kNoCompression,
-                &blob_offset, &blob_size);
-
-  std::unique_ptr<BlobFileReader> reader;
-  ReadOptions read_options;
-  Status s = BlobFileReader::Create(
-      immutable_options, read_options, FileOptions(), column_family_id,
-      /*blob_file_read_hist=*/nullptr, blob_file_number, nullptr /*IOTracer*/,
-      &reader);
-  ASSERT_TRUE(s.IsIOError());
-  ASSERT_EQ(reader, nullptr);
-}
-
 TEST_F(BlobFileReaderTest, Malformed) {
  // Write a blob file consisting of nothing but a header, and make sure we
  // detect the error when we open it for reading
@@ -833,7 +464,7 @@ TEST_F(BlobFileReaderTest, Malformed) {

    BlobLogWriter blob_log_writer(std::move(file_writer),
                                  immutable_options.clock, statistics,
-                                  blob_file_number, use_fsync, do_flush);
+                                  use_fsync, do_flush);

    BlobLogHeader header(column_family_id, kNoCompression, has_ttl,
                         expiration_range);
@@ -1217,6 +848,7 @@ class BlobFileReaderIOErrorTest

 INSTANTIATE_TEST_CASE_P(BlobFileReaderTest, BlobFileReaderIOErrorTest,
                        ::testing::ValuesIn(std::vector<std::string>{
+                            "BlobFileReader::OpenFile:GetFileSize",
                            "BlobFileReader::OpenFile:NewRandomAccessFile",
                            "BlobFileReader::ReadHeader:ReadFromFile",
                            "BlobFileReader::ReadFooter:ReadFromFile",
@@ -32,9 +32,6 @@ Status BlobGarbageMeter::GetBlobReferenceDetails(const ParsedInternalKey& ikey,
  if (blob_index.IsInlined() || blob_index.HasTTL()) {
    return Status::Corruption("Unexpected TTL/inlined blob index");
  }
-  if (blob_index.IsSameFile()) {
-    return Status::OK();
-  }

  *blob_file_number = blob_index.file_number();
  *bytes =
@@ -128,9 +125,7 @@ Status BlobGarbageMeter::ProcessEntityBlobReferences(
            !s.ok()) {
          return s;
        }
-        if (file_number != kInvalidBlobFileNumber) {
-          AddFlow(file_number, blob_bytes, is_inflow);
-        }
+        AddFlow(file_number, blob_bytes, is_inflow);
        return Status::OK();
      });
 }
@@ -151,24 +151,6 @@ TEST(BlobGarbageMeterTest, PlainValue) {
  ASSERT_TRUE(blob_garbage_meter.flows().empty());
 }

-TEST(BlobGarbageMeterTest, SameFileBlobIndex) {
-  constexpr char user_key[] = "user_key";
-  constexpr SequenceNumber seq = 123;
-
-  const InternalKey key(user_key, seq, kTypeBlobIndex);
-  const Slice key_slice = key.Encode();
-
-  std::string value;
-  BlobIndex::EncodeBlob(&value, kCurrentFileBlobIndexFileNumber,
-                        /*offset=*/123, /*size=*/456, kNoCompression);
-
-  BlobGarbageMeter blob_garbage_meter;
-
-  ASSERT_OK(blob_garbage_meter.ProcessInFlow(key_slice, value));
-  ASSERT_OK(blob_garbage_meter.ProcessOutFlow(key_slice, value));
-  ASSERT_TRUE(blob_garbage_meter.flows().empty());
-}
-
 TEST(BlobGarbageMeterTest, CorruptInternalKey) {
  constexpr char corrupt_key[] = "i_am_corrupt";
  const Slice key_slice(corrupt_key);
@@ -1,111 +0,0 @@
-//  Copyright (c) Meta Platforms, Inc. and affiliates.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include "db/blob/blob_gen2_format.h"
-
-#include <array>
-#include <cstring>
-#include <string>
-
-#include "file/random_access_file_reader.h"
-#include "file/writable_file_writer.h"
-#include "rocksdb/options.h"
-#include "rocksdb/slice.h"
-#include "table/format.h"
-#include "util/cast_util.h"
-#include "util/coding.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-Status ReadAndVerifySimpleGen2BlobRecord(
-    const ReadOptions& read_options, RandomAccessFileReader* file,
-    uint64_t record_offset, size_t payload_size, size_t record_size,
-    ChecksumType checksum_type, uint32_t base_context_checksum,
-    CompressionType expected_compression, char* buf) {
-  assert(file != nullptr);
-  assert(buf != nullptr);
-  assert(record_size == payload_size + kSimpleGen2BlobTrailerSize);
-
-  Slice result;
-  IOOptions opts;
-  IODebugContext dbg;
-  Status s = file->PrepareIOOptions(read_options, opts, &dbg);
-  if (s.ok()) {
-    s = file->Read(opts, record_offset, record_size, &result, buf, nullptr,
-                   &dbg);
-  }
-  if (!s.ok()) {
-    return s;
-  }
-  if (result.size() != record_size) {
-    return Status::Corruption("Could not read complete blob record");
-  }
-  // With mmap reads the data lands outside `buf`; copy it in so the caller can
-  // rely on `buf` owning the bytes (this is the only copy on the mmap path).
-  // TODO: fix this extra memcpy in the mmap case
-  if (result.data() != buf) {
-    memcpy(buf, result.data(), record_size);
-  }
-
-  const char* record = buf;
-  const CompressionType compression =
-      static_cast<CompressionType>(record[payload_size]);
-  if (compression != expected_compression) {
-    return Status::Corruption(
-        "Blob record compression does not match blob index");
-  }
-
-  if (read_options.verify_checksums) {
-    uint32_t stored = DecodeFixed32(record + payload_size + 1);
-    stored -= ChecksumModifierForContext(base_context_checksum, record_offset);
-    const uint32_t computed = ComputeBuiltinChecksumWithLastByte(
-        checksum_type, record, payload_size, record[payload_size]);
-    if (stored != computed) {
-      return Status::Corruption("Blob record checksum mismatch in " +
-                                file->file_name() + " offset " +
-                                std::to_string(record_offset) + " size " +
-                                std::to_string(payload_size));
-    }
-  }
-
-  if (compression != kNoCompression) {
-    return Status::Corruption("Blob record compression is not supported");
-  }
-  return Status::OK();
-}
-
-IOStatus WriteSimpleGen2BlobRecord(WritableFileWriter* file,
-                                   const WriteOptions& write_options,
-                                   ChecksumType checksum_type,
-                                   uint32_t base_context_checksum,
-                                   uint64_t record_offset, const Slice& payload,
-                                   CompressionType compression) {
-  assert(file != nullptr);
-  // Placeholder for future embedded blob compression support; only
-  // uncompressed payloads are currently written.
-  assert(compression == kNoCompression);
-
-  std::array<char, kSimpleGen2BlobTrailerSize> trailer;
-  trailer[0] = lossless_cast<char>(compression);
-  uint32_t checksum = ComputeBuiltinChecksumWithLastByte(
-      checksum_type, payload.data(), payload.size(), /*last_byte=*/trailer[0]);
-  checksum += ChecksumModifierForContext(base_context_checksum, record_offset);
-  EncodeFixed32(trailer.data() + 1, checksum);
-
-  IOOptions opts;
-  IOStatus io_s = WritableFileWriter::PrepareIOOptions(write_options, opts);
-  if (!io_s.ok()) {
-    return io_s;
-  }
-  if (!payload.empty()) {
-    io_s = file->Append(opts, payload);
-    if (!io_s.ok()) {
-      return io_s;
-    }
-  }
-  return file->Append(opts, Slice(trailer.data(), trailer.size()));
-}
-
-}  // namespace ROCKSDB_NAMESPACE
@@ -1,92 +0,0 @@
-//  Copyright (c) Meta Platforms, Inc. and affiliates.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-
-#include "cache/cache_key.h"
-#include "rocksdb/compression_type.h"
-#include "rocksdb/io_status.h"
-#include "rocksdb/rocksdb_namespace.h"
-#include "rocksdb/status.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-struct ReadOptions;
-struct WriteOptions;
-class RandomAccessFileReader;
-class WritableFileWriter;
-class Slice;
-enum ChecksumType : char;
-
-// "SimpleGen2Blob" is the second-generation on-disk format for a blob payload
-// referenced by a same-file / context-relative blob index. A record is just the
-// payload bytes followed by a small block-style trailer:
-//
-//   <payload bytes> <1-byte compression marker> <4-byte checksum>
-//
-// The checksum is a builtin block checksum over (payload + compression marker),
-// context-modified by the record's absolute file offset (see
-// ChecksumModifierForContext / ComputeBuiltinChecksumWithLastByte in
-// table/format.h) so that an identical payload at a different offset gets a
-// different stored checksum. Payloads are currently uncompressed only.
-//
-// This format is deliberately decoupled from any particular file type: the same
-// record shape is read out of SST files (embedded blobs) and is intended to be
-// reused by other blob-bearing files. The only file-type-specific inputs are
-// the byte source (a RandomAccessFileReader) and the checksum context (checksum
-// type + base context checksum), both passed in by the caller.
-inline constexpr size_t kSimpleGen2BlobTrailerSize = 5;
-
-// Cache key for the SimpleGen2Blob record at byte `record_offset` within a file
-// whose base cache key is `base_cache_key`. Delegates to the shared
-// OffsetableCacheKey::WithOffsetForMinSizeRecord scheme -- the exact same
-// scheme block-based SST data blocks use via BlockBasedTable::GetCacheKey --
-// which is valid because a SimpleGen2Blob record always carries a >= 5-byte
-// trailer. As a result the cache key is collision-free with the file's data
-// blocks even when the blob cache and block cache are the same cache, with no
-// separately maintained algorithm to drift out of sync.
-inline CacheKey GetSimpleGen2BlobCacheKey(
-    const OffsetableCacheKey& base_cache_key, uint64_t record_offset) {
-  return base_cache_key.WithOffsetForMinSizeRecord(record_offset);
-}
-
-// Reads a SimpleGen2Blob record of `record_size` bytes (which must equal
-// `payload_size + kSimpleGen2BlobTrailerSize`) from `file` at `record_offset`
-// into `buf` (capacity >= record_size) and verifies its compression marker and,
-// when read_options.verify_checksums is set, its context-modified checksum.
-//
-// `checksum_type` and `base_context_checksum` are the file's checksum context
-// (e.g. from the SST footer). `expected_compression` is the compression type
-// the caller expects the record to carry (from the blob index); it must match
-// the record's marker, and currently must be kNoCompression.
-//
-// On success, buf[0, payload_size) holds the verified, uncompressed payload
-// (the trailer remains at the tail of `buf` and can be ignored).
-Status ReadAndVerifySimpleGen2BlobRecord(
-    const ReadOptions& read_options, RandomAccessFileReader* file,
-    uint64_t record_offset, size_t payload_size, size_t record_size,
-    ChecksumType checksum_type, uint32_t base_context_checksum,
-    CompressionType expected_compression, char* buf);
-
-// Writes a SimpleGen2Blob record for `payload` at the current end of `file`,
-// which the caller asserts is byte offset `record_offset`. Appends the payload
-// bytes followed by the 5-byte trailer (compression marker + context-modified
-// builtin checksum), mirroring ReadAndVerifySimpleGen2BlobRecord so the on-disk
-// record format lives in one module.
-//
-// `checksum_type` and `base_context_checksum` are the file's checksum context
-// (e.g. from the SST footer). `compression` is the payload's compression type,
-// which currently must be kNoCompression.
-IOStatus WriteSimpleGen2BlobRecord(WritableFileWriter* file,
-                                   const WriteOptions& write_options,
-                                   ChecksumType checksum_type,
-                                   uint32_t base_context_checksum,
-                                   uint64_t record_offset, const Slice& payload,
-                                   CompressionType compression);
-
-}  // namespace ROCKSDB_NAMESPACE
@@ -7,7 +7,6 @@
 #include <sstream>
 #include <string>

-#include "db/blob/blob_constants.h"
 #include "rocksdb/compression_type.h"
 #include "util/coding.h"
 #include "util/compression.h"
@@ -58,14 +57,6 @@ class BlobIndex {

  bool IsInlined() const { return type_ == Type::kInlinedTTL; }

-  // True for a blob record stored in the same physical file as the table entry.
-  // Only embedded-blob SST reader/writer paths should interpret file number
-  // zero this way; generic blob metadata treats it as invalid.
-  bool IsSameFile() const {
-    return (type_ == Type::kBlob || type_ == Type::kBlobTTL) &&
-           file_number_ == kCurrentFileBlobIndexFileNumber;
-  }
-
  bool HasTTL() const {
    return type_ == Type::kInlinedTTL || type_ == Type::kBlobTTL;
  }
@@ -134,13 +125,8 @@ class BlobIndex {
    if (IsInlined()) {
      oss << "[inlined blob] value:" << value_.ToString(output_hex);
    } else {
-      oss << "[blob ref] file:";
-      if (IsSameFile()) {
-        oss << "same";
-      } else {
-        oss << file_number_;
-      }
-      oss << " offset:" << offset_ << " size:" << size_
+      oss << "[blob ref] file:" << file_number_ << " offset:" << offset_
+          << " size:" << size_
          << " compression: " << CompressionTypeToString(compression_);
    }

@@ -20,12 +20,10 @@ namespace ROCKSDB_NAMESPACE {

 BlobLogWriter::BlobLogWriter(std::unique_ptr<WritableFileWriter>&& dest,
                             SystemClock* clock, Statistics* statistics,
-                             uint64_t log_number, bool use_fs, bool do_flush,
-                             uint64_t boffset)
+                             bool use_fs, bool do_flush, uint64_t boffset)
    : dest_(std::move(dest)),
      clock_(clock),
      statistics_(statistics),
-      log_number_(log_number),
      block_offset_(boffset),
      use_fsync_(use_fs),
      do_flush_(do_flush),
@@ -74,10 +72,9 @@ Status BlobLogWriter::WriteHeader(const WriteOptions& write_options,
  return s;
 }

-Status BlobLogWriter::AppendFooter(const WriteOptions& write_options,
-                                   BlobLogFooter& footer,
-                                   std::string* checksum_method,
-                                   std::string* checksum_value) {
+Status BlobLogWriter::LegacyAppendFooterAndClose(
+    const WriteOptions& write_options, BlobLogFooter& footer,
+    std::string* checksum_method, std::string* checksum_value) {
  assert(block_offset_ != 0);
  assert(last_elem_type_ == kEtFileHdr || last_elem_type_ == kEtRecord);

@@ -32,8 +32,8 @@ class BlobLogWriter {
  // "*dest" must be initially empty.
  // "*dest" must remain live while this BlobLogWriter is in use.
  BlobLogWriter(std::unique_ptr<WritableFileWriter>&& dest, SystemClock* clock,
-                Statistics* statistics, uint64_t log_number, bool use_fsync,
-                bool do_flush, uint64_t boffset = 0);
+                Statistics* statistics, bool use_fsync, bool do_flush,
+                uint64_t boffset = 0);
  // No copying allowed
  BlobLogWriter(const BlobLogWriter&) = delete;
  BlobLogWriter& operator=(const BlobLogWriter&) = delete;
@@ -56,9 +56,10 @@ class BlobLogWriter {
                            const Slice& val, uint64_t* key_offset,
                            uint64_t* blob_offset);

-  Status AppendFooter(const WriteOptions& write_options, BlobLogFooter& footer,
-                      std::string* checksum_method,
-                      std::string* checksum_value);
+  Status LegacyAppendFooterAndClose(const WriteOptions& write_options,
+                                    BlobLogFooter& footer,
+                                    std::string* checksum_method,
+                                    std::string* checksum_value);

  Status WriteHeader(const WriteOptions& write_options, BlobLogHeader& header);

@@ -66,15 +67,12 @@ class BlobLogWriter {

  const WritableFileWriter* file() const { return dest_.get(); }

-  uint64_t get_log_number() const { return log_number_; }
-
  Status Sync(const WriteOptions& write_options);

 private:
  std::unique_ptr<WritableFileWriter> dest_;
  SystemClock* clock_;
  Statistics* statistics_;
-  uint64_t log_number_;
  uint64_t block_offset_;  // Current offset in block
  bool use_fsync_;
  bool do_flush_;
@@ -12,10 +12,7 @@
 #include "cache/charged_cache.h"
 #include "db/blob/blob_contents.h"
 #include "db/blob/blob_file_reader.h"
-#include "db/blob/blob_gen2_format.h"
 #include "db/blob/blob_log_format.h"
-#include "file/random_access_file_reader.h"
-#include "memory/memory_allocator_impl.h"
 #include "monitoring/statistics_impl.h"
 #include "options/cf_options.h"
 #include "table/get_context.h"
@@ -77,7 +74,6 @@ Status BlobSource::GetBlobFromCache(
    assert(cached_blob->GetValue());

    PERF_COUNTER_ADD(blob_cache_hit_count, 1);
-    PERF_COUNTER_ADD(blob_cache_read_byte, cached_blob->GetValue()->size());
    RecordTick(statistics_, BLOB_DB_CACHE_HIT);
    RecordTick(statistics_, BLOB_DB_CACHE_BYTES_READ,
               cached_blob->GetValue()->size());
@@ -308,96 +304,6 @@ Status BlobSource::GetBlob(const ReadOptions& read_options,
  return s;
 }

-Status BlobSource::GetSimpleGen2Blob(
-    const ReadOptions& read_options, const OffsetableCacheKey& base_cache_key,
-    RandomAccessFileReader* file, uint64_t record_offset, uint64_t payload_size,
-    ChecksumType checksum_type, uint32_t base_context_checksum,
-    CompressionType expected_compression, PinnableSlice* value,
-    uint64_t* bytes_read) {
-  assert(value);
-  assert(file);
-
-  const uint64_t record_size = payload_size + kSimpleGen2BlobTrailerSize;
-
-  // The cache key is derived from the SimpleGen2Blob format (shared scheme with
-  // block-based SST blocks); see GetSimpleGen2BlobCacheKey.
-  const CacheKey cache_key =
-      GetSimpleGen2BlobCacheKey(base_cache_key, record_offset);
-
-  Status s;
-
-  CacheHandleGuard<BlobContents> blob_handle;
-
-  // First, try to get the blob from the cache.
-  if (blob_cache_) {
-    Slice key = cache_key.AsSlice();
-    s = GetBlobFromCache(key, &blob_handle);
-    if (s.ok()) {
-      PinCachedBlob(&blob_handle, value);
-
-      // For consistency, the on-disk record size is assigned to bytes_read on
-      // both cache hits and misses.
-      if (bytes_read) {
-        *bytes_read = record_size;
-      }
-      return s;
-    }
-  }
-
-  assert(blob_handle.IsEmpty());
-
-  const bool no_io = read_options.read_tier == kBlockCacheTier;
-  if (no_io) {
-    return Status::Incomplete("Cannot read blob(s): no disk I/O allowed");
-  }
-
-  // Cache miss (or no cache configured). Read the record into a buffer
-  // allocated from the blob cache's memory allocator when we intend to insert
-  // it, exposing the uncompressed payload as BlobContents (the trailer just
-  // sits unused at the tail of the buffer).
-  MemoryAllocator* const allocator = (blob_cache_ && read_options.fill_cache)
-                                         ? blob_cache_.get()->memory_allocator()
-                                         : nullptr;
-
-  CacheAllocationPtr buf =
-      AllocateBlock(static_cast<size_t>(record_size), allocator);
-  s = ReadAndVerifySimpleGen2BlobRecord(
-      read_options, file, record_offset, static_cast<size_t>(payload_size),
-      static_cast<size_t>(record_size), checksum_type, base_context_checksum,
-      expected_compression, buf.get());
-  if (!s.ok()) {
-    return s;
-  }
-
-  std::unique_ptr<BlobContents> blob_contents(
-      new BlobContents(std::move(buf), static_cast<size_t>(payload_size)));
-
-  // Record the per-read statistics (mirrors BlobFileReader::GetBlob).
-  RecordTick(statistics_, BLOB_DB_BLOB_FILE_BYTES_READ, record_size);
-  PERF_COUNTER_ADD(blob_read_count, 1);
-  PERF_COUNTER_ADD(blob_read_byte, record_size);
-  if (bytes_read) {
-    *bytes_read = record_size;
-  }
-
-  if (blob_cache_ && read_options.fill_cache) {
-    // If filling cache is allowed and a cache is configured, try to put the
-    // blob into the cache.
-    Slice key = cache_key.AsSlice();
-    s = PutBlobIntoCache(key, &blob_contents, &blob_handle);
-    if (!s.ok()) {
-      return s;
-    }
-
-    PinCachedBlob(&blob_handle, value);
-  } else {
-    PinOwnedBlob(&blob_contents, value);
-  }
-
-  assert(s.ok());
-  return s;
-}
-
 void BlobSource::MultiGetBlob(const ReadOptions& read_options,
                              autovector<BlobFileReadRequests>& blob_reqs,
                              uint64_t* bytes_read) {
@@ -25,8 +25,6 @@ struct MutableCFOptions;
 class Status;
 class FilePrefetchBuffer;
 class Slice;
-class RandomAccessFileReader;
-enum ChecksumType : char;

 // BlobSource is a class that provides universal access to blobs, regardless of
 // whether they are in the blob cache, secondary cache, or (remote) storage.
@@ -61,41 +59,6 @@ class BlobSource {
                 FilePrefetchBuffer* prefetch_buffer, PinnableSlice* value,
                 uint64_t* bytes_read);

-  // Reads a SimpleGen2Blob payload (see db/blob/blob_gen2_format.h) through the
-  // blob value cache and BLOB_DB_* statistics. This is the counterpart to
-  // GetBlob() for the second-generation blob record format, which is read
-  // directly from a RandomAccessFileReader rather than from a traditional blob
-  // file.
-  //
-  // The cache key is derived from the SimpleGen2Blob format itself, not chosen
-  // by the caller: it is GetSimpleGen2BlobCacheKey(base_cache_key,
-  // record_offset), the same offset scheme block-based SST blocks use. The
-  // caller supplies only its file's `base_cache_key` (db_id / db_session_id /
-  // file_number). This keeps blob records collision-free with the file's data
-  // blocks even when the blob cache and block cache are the same cache.
-  //
-  // `file`, `record_offset`, `payload_size`, `checksum_type`,
-  // `base_context_checksum`, and `expected_compression` are the inputs to the
-  // SimpleGen2Blob reader used on a cache miss (see
-  // ReadAndVerifySimpleGen2BlobRecord). The on-disk record size (payload +
-  // trailer) is reported via `*bytes_read` (when non-null) and the
-  // BLOB_DB_BLOB_FILE_BYTES_READ / blob_read_byte counters, consistently on
-  // both cache hits and misses.
-  //
-  // On a cache hit, pins the cached value into `*value` (no copy). On a miss,
-  // reads + verifies the record into a cache-allocator buffer, records the
-  // per-read stats, inserts it into the cache (when configured and fill_cache
-  // is set), and pins it into `*value`. If blob_cache_ is not configured, the
-  // record is still read and read stats recorded, just without a cache
-  // lookup/insert.
-  Status GetSimpleGen2Blob(const ReadOptions& read_options,
-                           const OffsetableCacheKey& base_cache_key,
-                           RandomAccessFileReader* file, uint64_t record_offset,
-                           uint64_t payload_size, ChecksumType checksum_type,
-                           uint32_t base_context_checksum,
-                           CompressionType expected_compression,
-                           PinnableSlice* value, uint64_t* bytes_read);
-
  // Read multiple blobs from the underlying cache or blob file(s).
  //
  // If successful, returns ok and sets "result" in the elements of "blob_reqs"
@@ -59,8 +59,7 @@ void WriteBlobFile(const ImmutableOptions& immutable_options,
  constexpr bool do_flush = false;

  BlobLogWriter blob_log_writer(std::move(file_writer), immutable_options.clock,
-                                statistics, blob_file_number, use_fsync,
-                                do_flush);
+                                statistics, use_fsync, do_flush);

  BlobLogHeader header(column_family_id, compression, has_ttl,
                       expiration_range_header);
@@ -100,8 +99,8 @@ void WriteBlobFile(const ImmutableOptions& immutable_options,

  std::string checksum_method;
  std::string checksum_value;
-  ASSERT_OK(blob_log_writer.AppendFooter(WriteOptions(), footer,
-                                         &checksum_method, &checksum_value));
+  ASSERT_OK(blob_log_writer.LegacyAppendFooterAndClose(
+      WriteOptions(), footer, &checksum_method, &checksum_value));
 }

 }  // anonymous namespace
@@ -229,7 +228,6 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
    // Retrieved the blob cache num_blobs * 3 times via TEST_BlobInCache,
    // GetBlob, and TEST_BlobInCache.
    ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count, 0);
-    ASSERT_EQ((int)get_perf_context()->blob_cache_read_byte, 0);
    ASSERT_EQ((int)get_perf_context()->blob_read_count, num_blobs);
    ASSERT_EQ((int)get_perf_context()->blob_read_byte, total_bytes);
    ASSERT_GE((int)get_perf_context()->blob_checksum_time, 0);
@@ -263,8 +261,6 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
      blob_bytes += blob_sizes[i];
      total_bytes += bytes_read;
      ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count, i);
-      ASSERT_EQ((int)get_perf_context()->blob_cache_read_byte,
-                blob_bytes - blob_sizes[i]);
      ASSERT_EQ((int)get_perf_context()->blob_read_count, i + 1);
      ASSERT_EQ((int)get_perf_context()->blob_read_byte, total_bytes);

@@ -272,13 +268,11 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
                                               blob_offsets[i]));

      ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count, i + 1);
-      ASSERT_EQ((int)get_perf_context()->blob_cache_read_byte, blob_bytes);
      ASSERT_EQ((int)get_perf_context()->blob_read_count, i + 1);
      ASSERT_EQ((int)get_perf_context()->blob_read_byte, total_bytes);
    }

    ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count, num_blobs);
-    ASSERT_EQ((int)get_perf_context()->blob_cache_read_byte, blob_bytes);
    ASSERT_EQ((int)get_perf_context()->blob_read_count, num_blobs);
    ASSERT_EQ((int)get_perf_context()->blob_read_byte, total_bytes);

@@ -317,7 +311,6 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
    // Retrieved the blob cache num_blobs * 3 times via TEST_BlobInCache,
    // GetBlob, and TEST_BlobInCache.
    ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count, num_blobs * 3);
-    ASSERT_EQ((int)get_perf_context()->blob_cache_read_byte, blob_bytes * 3);
    ASSERT_EQ((int)get_perf_context()->blob_read_count, 0);  // without i/o
    ASSERT_EQ((int)get_perf_context()->blob_read_byte, 0);   // without i/o

@@ -696,8 +689,6 @@ TEST_F(BlobSourceTest, MultiGetBlobsFromMultiFiles) {
    // TEST_BlobInCache.
    ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count,
              num_blobs * blob_files);
-    ASSERT_EQ((int)get_perf_context()->blob_cache_read_byte,
-              blob_value_bytes * blob_files);
    ASSERT_EQ((int)get_perf_context()->blob_read_count,
              num_blobs * blob_files);  // blocking i/o
    ASSERT_EQ((int)get_perf_context()->blob_read_byte,
@@ -758,8 +749,6 @@ TEST_F(BlobSourceTest, MultiGetBlobsFromMultiFiles) {
    // via MultiGetBlob and TEST_BlobInCache.
    ASSERT_EQ((int)get_perf_context()->blob_cache_hit_count,
              num_blobs * blob_files * 2);
-    ASSERT_EQ((int)get_perf_context()->blob_cache_read_byte,
-              blob_value_bytes * blob_files * 2);
    ASSERT_EQ((int)get_perf_context()->blob_read_count,
              0);  // blocking i/o
    ASSERT_EQ((int)get_perf_context()->blob_read_byte,
@@ -278,7 +278,7 @@ Status BlobWriteBatchTransformer::MergeCF(uint32_t column_family_id,
 Status BlobWriteBatchTransformer::PutBlobIndexCF(uint32_t column_family_id,
                                                 const Slice& key,
                                                 const Slice& value) {
-  // Already a blob index -- pass through unchanged.
+  // Already a blob index — pass through unchanged.
  return WriteBatchInternal::PutBlobIndex(output_batch_, column_family_id, key,
                                          value);
 }
@@ -35,7 +35,7 @@ struct BlobDirectWriteSettings {
  CompressionType compression_type = kNoCompression;
  // Compression options for newly written blob records.
  CompressionOptions compression_opts;
-  // Raw pointer -- the Cache is owned by ColumnFamilyOptions and outlives all
+  // Raw pointer — the Cache is owned by ColumnFamilyOptions and outlives all
  // settings snapshots. Using raw avoids 2 atomic ref-count ops per Put().
  Cache* blob_cache = nullptr;
  // Blob-cache prepopulation policy for direct-write records.
@@ -1620,47 +1620,6 @@ TEST_P(DBBlobBasicIOErrorTest, GetBlob_IOError) {
  SyncPoint::GetInstance()->ClearAllCallBacks();
 }

-TEST_P(DBBlobBasicIOErrorTest, GetEntityMergeWithBlobBaseIOError) {
-  // Goal: verify GetEntity preserves injected blob-read IOErrors when merge
-  // reads a blob-backed base value, instead of laundering them into Corruption.
-  // The test writes a blob-backed base value plus a merge operand, then injects
-  // an IOError at blob read time and checks both GetEntity and Get see it.
-  Options options;
-  options.env = fault_injection_env_.get();
-  options.enable_blob_files = true;
-  options.min_blob_size = 0;
-  options.merge_operator = MergeOperators::CreateStringAppendOperator();
-
-  Reopen(options);
-
-  constexpr char key[] = "key";
-  constexpr char base_value[] = "base_value";
-
-  ASSERT_OK(Put(key, base_value));
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(Merge(key, "merge_operand"));
-  ASSERT_OK(Flush());
-
-  SyncPoint::GetInstance()->SetCallBack(sync_point_, [this](void* /* arg */) {
-    fault_injection_env_->SetFilesystemActive(false,
-                                              Status::IOError(sync_point_));
-  });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  PinnableWideColumns entity_result;
-  Status s = db_->GetEntity(ReadOptions(), db_->DefaultColumnFamily(), key,
-                            &entity_result);
-  ASSERT_TRUE(s.IsIOError()) << "Expected IOError but got: " << s.ToString();
-
-  PinnableSlice get_result;
-  s = db_->Get(ReadOptions(), db_->DefaultColumnFamily(), key, &get_result);
-  ASSERT_TRUE(s.IsIOError()) << "Expected IOError but got: " << s.ToString();
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
 TEST_P(DBBlobBasicIOErrorMultiGetTest, MultiGetBlobs_IOError) {
  Options options = GetDefaultOptions();
  options.env = fault_injection_env_.get();
@@ -10,14 +10,11 @@

 #include <algorithm>
 #include <array>
-#include <functional>
 #include <limits>
 #include <mutex>
 #include <set>
 #include <sstream>
 #include <string>
-#include <unordered_set>
-#include <utility>
 #include <vector>

 #include "cache/compressed_secondary_cache.h"
@@ -29,12 +26,10 @@
 #include "db/db_test_util.h"
 #include "db/db_with_timestamp_test_util.h"
 #include "db/wide/wide_column_test_util.h"
-#include "env/composite_env_wrapper.h"
 #include "file/filename.h"
 #include "file/random_access_file_reader.h"
 #include "port/stack_trace.h"
 #include "rocksdb/convenience.h"
-#include "rocksdb/file_system.h"
 #include "rocksdb/trace_reader_writer.h"
 #include "rocksdb/trace_record.h"
 #include "rocksdb/utilities/replayer.h"
@@ -106,206 +101,6 @@ class RecordingBlobDirectWritePartitionStrategy
  std::vector<Call> calls_;
 };

-namespace {
-
-// Matches BlobDB file names so the test filesystem can special-case only active
-// blob files without changing unrelated file opens.
-bool IsBlobFilePath(const std::string& fname) {
-  const size_t basename_pos = fname.find_last_of("/\\");
-  const std::string basename = basename_pos == std::string::npos
-                                   ? fname
-                                   : fname.substr(basename_pos + 1);
-  uint64_t file_number = 0;
-  FileType file_type = kWalFile;
-  return ParseFileName(basename, &file_number, &file_type) &&
-         file_type == kBlobFile;
-}
-
-// Keeps track of when an active blob file stops being writer-visible so the
-// test filesystem can model current-size visibility only while the file remains
-// active.
-class ActiveBlobVisibilityWritableFile : public FSWritableFileOwnerWrapper {
- public:
-  ActiveBlobVisibilityWritableFile(std::unique_ptr<FSWritableFile>&& target,
-                                   std::function<void()> on_close)
-      : FSWritableFileOwnerWrapper(std::move(target)),
-        on_close_(std::move(on_close)) {}
-
-  ~ActiveBlobVisibilityWritableFile() override { DeactivateOnce(); }
-
-  IOStatus Close(const IOOptions& options, IODebugContext* dbg) override {
-    IOStatus s = target()->Close(options, dbg);
-    DeactivateOnce();
-    return s;
-  }
-
- private:
-  void DeactivateOnce() {
-    if (on_close_) {
-      on_close_();
-      on_close_ = nullptr;
-    }
-  }
-
-  std::function<void()> on_close_;
-};
-
-// Simulates a remote readable file whose GetFileSize() either exposes the live
-// on-disk size for default-contract active blobs or hides it for
-// append-only-no-readers files.
-class ActiveBlobVisibilityRandomAccessFile
-    : public FSRandomAccessFileOwnerWrapper {
- public:
-  ActiveBlobVisibilityRandomAccessFile(
-      std::unique_ptr<FSRandomAccessFile>&& target, bool expose_current_size,
-      std::shared_ptr<FileSystem> underlying_fs, std::string fname)
-      : FSRandomAccessFileOwnerWrapper(std::move(target)),
-        expose_current_size_(expose_current_size),
-        underlying_fs_(std::move(underlying_fs)),
-        fname_(std::move(fname)) {}
-
-  IOStatus GetFileSize(uint64_t* result) override {
-    if (!expose_current_size_) {
-      *result = 0;
-      return IOStatus::OK();
-    }
-    // Delegate to the underlying FS path-level GetFileSize (bypassing the
-    // wrapper that reports 0 for active blobs) to simulate a remote FS that
-    // exposes the current file size through the open handle.
-    return underlying_fs_->GetFileSize(fname_, IOOptions(), result,
-                                       /*dbg=*/nullptr);
-  }
-
- private:
-  const bool expose_current_size_;
-  std::shared_ptr<FileSystem> underlying_fs_;
-  std::string fname_;
-};
-
-// Models a remote filesystem where active direct-write blobs are only
-// reader-visible when the writer does not promise no concurrent readers.
-class RemoteBlobVisibilityFileSystem : public FileSystemWrapper {
- public:
-  explicit RemoteBlobVisibilityFileSystem(const std::shared_ptr<FileSystem>& fs)
-      : FileSystemWrapper(fs) {}
-
-  static const char* kClassName() { return "RemoteBlobVisibilityFileSystem"; }
-  const char* Name() const override { return kClassName(); }
-
-  IOStatus NewWritableFile(const std::string& fname, const FileOptions& opts,
-                           std::unique_ptr<FSWritableFile>* result,
-                           IODebugContext* dbg) override {
-    std::unique_ptr<FSWritableFile> file;
-    IOStatus s = target()->NewWritableFile(fname, opts, &file, dbg);
-    if (!s.ok() || !IsBlobFilePath(fname)) {
-      *result = std::move(file);
-      return IOStatus(std::move(s));
-    }
-
-    const bool has_no_reopen_for_write_contract = HasFileOpenContract(
-        opts.open_contract, FileOpenContract::kNoReopenForWrite);
-    const bool has_no_readers_while_open_for_write_contract =
-        HasFileOpenContract(opts.open_contract,
-                            FileOpenContract::kNoReadersWhileOpenForWrite);
-    {
-      std::lock_guard<std::mutex> lock(mu_);
-      saw_no_reopen_for_write_writer_contract_ |=
-          has_no_reopen_for_write_contract;
-      saw_no_readers_while_open_for_write_writer_contract_ |=
-          has_no_readers_while_open_for_write_contract;
-      if (!has_no_readers_while_open_for_write_contract) {
-        active_blob_paths_.insert(fname);
-      }
-    }
-
-    if (has_no_readers_while_open_for_write_contract) {
-      *result = std::move(file);
-      return IOStatus::OK();
-    }
-
-    result->reset(new ActiveBlobVisibilityWritableFile(
-        std::move(file), [this, tracked_path = std::string(fname)]() {
-          DeactivateBlobPath(tracked_path);
-        }));
-    return IOStatus::OK();
-  }
-
-  IOStatus NewRandomAccessFile(const std::string& fname,
-                               const FileOptions& opts,
-                               std::unique_ptr<FSRandomAccessFile>* result,
-                               IODebugContext* dbg) override {
-    std::unique_ptr<FSRandomAccessFile> file;
-    IOStatus s = target()->NewRandomAccessFile(fname, opts, &file, dbg);
-    if (!s.ok() || !IsBlobFilePath(fname)) {
-      *result = std::move(file);
-      return IOStatus(std::move(s));
-    }
-
-    const bool has_no_readers_while_open_for_write_contract =
-        HasFileOpenContract(opts.open_contract,
-                            FileOpenContract::kNoReadersWhileOpenForWrite);
-    const bool active_blob = IsActiveBlobPath(fname);
-    {
-      std::lock_guard<std::mutex> lock(mu_);
-      saw_no_readers_while_open_for_write_reader_contract_ |=
-          has_no_readers_while_open_for_write_contract;
-    }
-
-    if (!active_blob) {
-      *result = std::move(file);
-      return IOStatus::OK();
-    }
-
-    result->reset(new ActiveBlobVisibilityRandomAccessFile(
-        std::move(file), !has_no_readers_while_open_for_write_contract, target_,
-        fname));
-    return IOStatus::OK();
-  }
-
-  IOStatus GetFileSize(const std::string& fname, const IOOptions& options,
-                       uint64_t* file_size, IODebugContext* dbg) override {
-    if (IsActiveBlobPath(fname)) {
-      *file_size = 0;
-      return IOStatus::OK();
-    }
-    return target()->GetFileSize(fname, options, file_size, dbg);
-  }
-
-  bool SawNoReopenForWriteWriterContract() const {
-    std::lock_guard<std::mutex> lock(mu_);
-    return saw_no_reopen_for_write_writer_contract_;
-  }
-
-  bool SawNoReadersWhileOpenForWriteWriterContract() const {
-    std::lock_guard<std::mutex> lock(mu_);
-    return saw_no_readers_while_open_for_write_writer_contract_;
-  }
-
-  bool SawNoReadersWhileOpenForWriteReaderContract() const {
-    std::lock_guard<std::mutex> lock(mu_);
-    return saw_no_readers_while_open_for_write_reader_contract_;
-  }
-
- private:
-  void DeactivateBlobPath(const std::string& fname) {
-    std::lock_guard<std::mutex> lock(mu_);
-    active_blob_paths_.erase(fname);
-  }
-
-  bool IsActiveBlobPath(const std::string& fname) const {
-    std::lock_guard<std::mutex> lock(mu_);
-    return active_blob_paths_.find(fname) != active_blob_paths_.end();
-  }
-
-  mutable std::mutex mu_;
-  bool saw_no_reopen_for_write_writer_contract_ = false;
-  bool saw_no_readers_while_open_for_write_writer_contract_ = false;
-  bool saw_no_readers_while_open_for_write_reader_contract_ = false;
-  std::unordered_set<std::string> active_blob_paths_;
-};
-
-}  // namespace
-
 class DBBlobDirectWriteTest : public DBTestBase {
 protected:
  DBBlobDirectWriteTest()
@@ -1021,30 +816,6 @@ TEST_F(DBBlobDirectWriteTest, DirectWriteImmutableMemtableRead) {
  verify_reads();
 }

-// Verifies active blob direct-write files promise no write reopen without also
-// promising no concurrent readers.
-TEST_F(DBBlobDirectWriteTest, DirectWriteUsesReadableContractForRemoteFile) {
-  auto remote_fs =
-      std::make_shared<RemoteBlobVisibilityFileSystem>(env_->GetFileSystem());
-  std::unique_ptr<Env> remote_env(new CompositeEnvWrapper(env_, remote_fs));
-
-  Options options = GetDirectWriteOptions();
-  options.env = remote_env.get();
-  Reopen(options);
-
-  const std::string key = "remote_blob_key";
-  const std::string value(128, 'w');
-
-  ASSERT_OK(Put(key, value));
-  ASSERT_TRUE(remote_fs->SawNoReopenForWriteWriterContract());
-  ASSERT_FALSE(remote_fs->SawNoReadersWhileOpenForWriteWriterContract());
-
-  ASSERT_EQ(Get(key), value);
-  ASSERT_FALSE(remote_fs->SawNoReadersWhileOpenForWriteReaderContract());
-
-  Close();
-}
-
 TEST_F(DBBlobDirectWriteTest, DirectWriteRefreshesReaderAfterFlush) {
  Options options = GetDirectWriteOptions();
  options.blob_direct_write_partitions = 1;
@@ -25,9 +25,6 @@
 #include "file/filename.h"
 #include "port/port.h"
 #include "port/stack_trace.h"
-#include "rocksdb/perf_context.h"
-#include "rocksdb/sst_file_writer.h"
-#include "rocksdb/table.h"
 #include "util/string_util.h"
 #include "utilities/merge_operators.h"

@@ -44,18 +41,6 @@ void CorruptPinnedBlobIndexOnCleanup(void* arg1, void* /*arg2*/) {

 }  // namespace

-TEST(BlobIndexTest, SameFileBlobIndex) {
-  std::string encoded;
-  BlobIndex::EncodeBlob(&encoded, kCurrentFileBlobIndexFileNumber,
-                        /*offset=*/123, /*size=*/456, kNoCompression);
-
-  BlobIndex blob_index;
-  ASSERT_OK(blob_index.DecodeFrom(encoded));
-  EXPECT_TRUE(blob_index.IsSameFile());
-  EXPECT_EQ(blob_index.file_number(), kCurrentFileBlobIndexFileNumber);
-  EXPECT_NE(blob_index.DebugString(false).find("file:same"), std::string::npos);
-}
-
 // kTypeBlobIndex is a value type used by BlobDB only. The base rocksdb
 // should accept the value type on write, and report not supported value
 // for reads, unless caller request for it explicitly. The base rocksdb
@@ -143,16 +128,6 @@ class DBBlobIndexTest : public DBTestBase {
        columns, s, is_blob_index, value_found);
  }

-  bool MaybeResolveMemtableBlobValueForTest(const Slice& key,
-                                            const BlobFetcher* blob_fetcher,
-                                            PinnableSlice* value,
-                                            PinnableWideColumns* columns,
-                                            Status* s, bool* is_blob_index,
-                                            bool* value_found = nullptr) {
-    return DBImpl::MaybeResolveMemtableBlobValue(
-        key, blob_fetcher, value, columns, s, is_blob_index, value_found);
-  }
-
  Options GetTestOptions() {
    Options options;
    options.env = CurrentOptions().env;
@@ -296,485 +271,6 @@ TEST_F(DBBlobIndexTest,
  ASSERT_EQ(static_cast<char>(BlobIndex::Type::kUnknown), blob_index.front());
 }

-TEST_F(DBBlobIndexTest,
-       MaybeResolveMemtableBlobValueWithoutFetcherFailsClosed) {
-  // Goal: if a readonly/secondary memtable hit produces a blob-backed payload
-  // but no BlobFetcher is available, the helper must fail closed instead of
-  // handing raw blob-index bytes back to the caller as if they were the value.
-  std::string blob_index;
-  BlobIndex::EncodeBlob(&blob_index, /*file_number=*/123, /*offset=*/456,
-                        /*size=*/789, kNoCompression);
-
-  PinnableSlice value;
-  value.GetSelf()->assign(blob_index.data(), blob_index.size());
-  value.PinSelf();
-
-  Status s = Status::OK();
-  bool is_blob_index = true;
-  ASSERT_TRUE(MaybeResolveMemtableBlobValueForTest(
-      Slice("key"), /*blob_fetcher=*/nullptr, &value, /*columns=*/nullptr, &s,
-      &is_blob_index));
-
-  ASSERT_TRUE(s.IsNotSupported()) << s.ToString();
-  ASSERT_TRUE(value.empty());
-  ASSERT_FALSE(is_blob_index);
-}
-
-TEST_F(DBBlobIndexTest, ReadOnlyGetImplReturnsBlobIndexWhenRequested) {
-  // Goal: cover the internal read-only GetImpl contract when the caller
-  // explicitly asks for raw blob-index bytes via `is_blob_index`. Recovery
-  // keeps the blob index in the memtable, and the read-only path must preserve
-  // the encoded index instead of eagerly resolving or rejecting it.
-  Options options = GetTestOptions();
-
-  DestroyAndReopen(options);
-
-  std::string blob_index;
-  BlobIndex::EncodeInlinedTTL(&blob_index, /*expiration=*/9876543210, "blob");
-
-  WriteBatch batch;
-  ASSERT_OK(PutBlobIndex(&batch, "blob_key", blob_index));
-  ASSERT_OK(Write(&batch));
-
-  Close();
-  options.avoid_flush_during_recovery = true;
-  ASSERT_OK(ReadOnlyReopen(options));
-
-  bool is_blob_index = false;
-  ASSERT_EQ(blob_index, GetImpl("blob_key", &is_blob_index));
-  ASSERT_TRUE(is_blob_index);
-}
-
-// Regression test for a same-file (embedded) BlobIndex being exposed
-// unresolved through an iterator. With index_type=kBinarySearchWithFirstKey
-// and allow_unprepared_value (the default for DB iterators), the block-based
-// table iterator can sit in the is_at_first_key_from_index_ state and return
-// the raw kTypeBlobIndex internal key from the index, while value() resolves
-// the same-file blob to its plain payload. DBIter then reads the stale
-// kTypeBlobIndex type and routes the already-resolved plain value through the
-// blob-index path, corrupting/misreading it.
-//
-// Forcing one entry per data block makes every embedded blob the first key of
-// a block, reliably triggering the deferred-first-key state on both SeekToFirst
-// and forward block transitions.
-TEST_F(DBBlobIndexTest, EmbeddedBlobIteratorWithFirstKeyIndex) {
-  Options options = GetTestOptions();
-  options.create_if_missing = true;
-  BlockBasedTableOptions bbto;
-  bbto.index_type =
-      BlockBasedTableOptions::IndexType::kBinarySearchWithFirstKey;
-  // Soft limit of 1 byte starts a new data block after every entry.
-  bbto.block_size = 1;
-  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
-  DestroyAndReopen(options);
-
-  // Build an embedded-blob SST whose large values are stored as same-file blob
-  // records (table entries become same-file BlobIndex references).
-  const std::string sst_path = dbname_ + "/embedded_first_key.sst";
-  SstFileWriterEmbeddedBlobOptions embedded_blob_options;
-  embedded_blob_options.min_blob_size = 8;
-
-  const std::string big1(1024, 'x');
-  const std::string big2(1024, 'y');
-  const std::string big3(1024, 'z');
-
-  SstFileWriter writer(EnvOptions(), options);
-  ASSERT_OK(writer.OpenWithEmbeddedBlobs(sst_path, embedded_blob_options));
-  ASSERT_OK(writer.Put("k1", big1));
-  ASSERT_OK(writer.Put("k2", big2));
-  ASSERT_OK(writer.Put("k3", big3));
-  ASSERT_OK(writer.Finish());
-
-  ASSERT_OK(db_->IngestExternalFile({sst_path}, IngestExternalFileOptions()));
-
-  // Point lookups resolve same-file blobs before exposing them, so Get works.
-  ASSERT_EQ(Get("k1"), big1);
-  ASSERT_EQ(Get("k2"), big2);
-  ASSERT_EQ(Get("k3"), big3);
-
-  // Iterator path: the bug manifests here.
-  std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
-  iter->SeekToFirst();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_OK(iter->status());
-  EXPECT_EQ(iter->key(), "k1");
-  EXPECT_EQ(iter->value(), big1);
-
-  iter->Next();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_OK(iter->status());
-  EXPECT_EQ(iter->key(), "k2");
-  EXPECT_EQ(iter->value(), big2);
-
-  iter->Next();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_OK(iter->status());
-  EXPECT_EQ(iter->key(), "k3");
-  EXPECT_EQ(iter->value(), big3);
-
-  iter->Next();
-  ASSERT_FALSE(iter->Valid());
-  ASSERT_OK(iter->status());
-
-  // Seek directly to a block whose first key is an embedded blob.
-  iter->Seek("k2");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_OK(iter->status());
-  EXPECT_EQ(iter->key(), "k2");
-  EXPECT_EQ(iter->value(), big2);
-}
-
-// Backward iteration (Prev / SeekForPrev) over an embedded-blob SST must work,
-// including for wide-column entities whose same-file blob columns are resolved
-// into an iterator-owned buffer. DBIter requires the underlying iterator's
-// value to be pinned for backward iteration; EmbeddedBlobResolvingIterator
-// therefore pins resolved values -- both whole-value blob payloads and rebuilt
-// wide-column values -- and hands their cleanup to the PinnedIteratorsManager
-// across repositioning. Before that, backward iteration over the wide-column
-// entity returned NotSupported (or tripped the IsValuePinned() assertion).
-TEST_F(DBBlobIndexTest, EmbeddedBlobBackwardIteration) {
-  Options options = GetTestOptions();
-  options.create_if_missing = true;
-  DestroyAndReopen(options);
-
-  const std::string sst_path = dbname_ + "/embedded_backward.sst";
-  SstFileWriterEmbeddedBlobOptions embedded_blob_options;
-  embedded_blob_options.min_blob_size = 8;
-
-  // Whole-value same-file blobs.
-  const std::string big1(1024, 'x');
-  const std::string big3(1024, 'z');
-  // Wide-column entity: a small (inline) default column plus a large
-  // (embedded, same-file blob) non-default column -- the mixed wide-column
-  // path whose resolved value lands in an iterator-owned buffer.
-  const std::string k2_default(2, 'd');
-  const std::string k2_big_col(1024, 'c');
-  const WideColumns k2_columns{{kDefaultWideColumnName, k2_default},
-                               {"big", k2_big_col}};
-
-  SstFileWriter writer(EnvOptions(), options);
-  ASSERT_OK(writer.OpenWithEmbeddedBlobs(sst_path, embedded_blob_options));
-  ASSERT_OK(writer.Put("k1", big1));
-  ASSERT_OK(writer.PutEntity("k2", k2_columns));
-  ASSERT_OK(writer.Put("k3", big3));
-  ASSERT_OK(writer.Finish());
-
-  ASSERT_OK(db_->IngestExternalFile({sst_path}, IngestExternalFileOptions()));
-
-  std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
-
-  // Backward scan via SeekToLast + Prev.
-  iter->SeekToLast();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_OK(iter->status());
-  EXPECT_EQ(iter->key(), "k3");
-  EXPECT_EQ(iter->value(), big3);
-
-  iter->Prev();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_OK(iter->status());
-  EXPECT_EQ(iter->key(), "k2");
-  EXPECT_EQ(iter->value(), k2_default);
-  EXPECT_EQ(iter->columns(), k2_columns);
-
-  iter->Prev();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_OK(iter->status());
-  EXPECT_EQ(iter->key(), "k1");
-  EXPECT_EQ(iter->value(), big1);
-
-  iter->Prev();
-  ASSERT_FALSE(iter->Valid());
-  ASSERT_OK(iter->status());
-
-  // SeekForPrev directly onto the wide-column entity, then step back.
-  iter->SeekForPrev("k2");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_OK(iter->status());
-  EXPECT_EQ(iter->key(), "k2");
-  EXPECT_EQ(iter->value(), k2_default);
-  EXPECT_EQ(iter->columns(), k2_columns);
-
-  iter->Prev();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_OK(iter->status());
-  EXPECT_EQ(iter->key(), "k1");
-  EXPECT_EQ(iter->value(), big1);
-}
-
-// Regression test for T277566778. If resolving a same-file ("embedded") blob
-// fails during compaction (e.g. a blob-region read fault), the error must be
-// surfaced as-is. It must NOT be masked by feeding the raw, unresolved
-// same-file BlobIndex downstream, where FileMetaData::UpdateBoundaries would
-// (correctly) reject file number 0 and report a misleading "Invalid blob file
-// number" corruption. The EmbeddedBlobResolvingIterator must not expose an
-// unresolved same-file value on error: for eager (compaction) callers it
-// resolves during positioning so the error is visible via status()/Valid()
-// before value().
-TEST_F(DBBlobIndexTest, EmbeddedBlobResolveErrorDuringCompactionNotMasked) {
-  Options options = GetTestOptions();
-  options.create_if_missing = true;
-  options.disable_auto_compactions = true;
-  DestroyAndReopen(options);
-
-  const std::string sst_path = dbname_ + "/embedded_resolve_err.sst";
-  SstFileWriterEmbeddedBlobOptions embedded_blob_options;
-  embedded_blob_options.min_blob_size = 8;
-
-  // Wide-column entity with a large (embedded, same-file blob) column: the
-  // mixed path whose resolution reads the blob region during compaction.
-  const std::string big_col(1024, 'c');
-  const WideColumns columns{{kDefaultWideColumnName, "d"}, {"big", big_col}};
-
-  SstFileWriter writer(EnvOptions(), options);
-  ASSERT_OK(writer.OpenWithEmbeddedBlobs(sst_path, embedded_blob_options));
-  ASSERT_OK(writer.PutEntity("k2", columns));
-  ASSERT_OK(writer.Finish());
-  ASSERT_OK(db_->IngestExternalFile({sst_path}, IngestExternalFileOptions()));
-
-  // Add keys straddling the entity so a real compaction (not a trivial move)
-  // reads and resolves the embedded entity.
-  ASSERT_OK(Put("k1", "v1"));
-  ASSERT_OK(Put("k3", "v3"));
-  ASSERT_OK(Flush());
-
-  // Inject a resolution failure only during the compaction below, simulating a
-  // blob-region read fault.
-  const Status kInjected = Status::IOError("injected embedded blob read error");
-  SyncPoint::GetInstance()->SetCallBack(
-      "BlockBasedTable::MaybeResolveEmbeddedValue:InjectError",
-      [&](void* arg) { *static_cast<Status*>(arg) = kInjected; });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  const Status s = db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-
-  // The compaction must fail with the injected read error, NOT a masked
-  // "Invalid blob file number" corruption.
-  ASSERT_NOK(s);
-  EXPECT_TRUE(s.IsIOError()) << s.ToString();
-  EXPECT_EQ(s.ToString().find("Invalid blob file number"), std::string::npos)
-      << s.ToString();
-}
-
-// Regression test for T277310719, the whole-value (kTypeBlobIndex) sibling of
-// the wide-column-entity case above (T277566778). Both share one root cause: on
-// a blob-region resolution error during compaction, the
-// EmbeddedBlobResolvingIterator must not fall back to exposing the raw,
-// unresolved same-file value.
-//
-// The whole-value variant is more dangerous than the entity variant because it
-// escapes the FileMetaData::UpdateBoundaries tripwire: ResolveKeyType()
-// rewrites the key type kTypeBlobIndex -> kTypeValue (no I/O, always succeeds),
-// so on a masked resolution error the emitted entry is {kTypeValue, raw
-// BlobIndex bytes}. UpdateBoundaries only scans kTypeBlobIndex/entity types, so
-// unlike the entity variant it does NOT reject it -- the masked error slips
-// through, a corrupt {kTypeValue, BlobIndex} record is written to the
-// compaction output, and a later point lookup reads those raw BlobIndex bytes
-// back as the value (in db_stress this surfaced as the
-// ExpectedValue::IsValueBaseValid assertion, not "Invalid blob file number").
-// The eager (compaction) resolver must surface the error via status()/Valid()
-// before value() is consumed.
-TEST_F(DBBlobIndexTest,
-       EmbeddedBlobResolveErrorWholeValueDuringCompactionNotMasked) {
-  Options options = GetTestOptions();
-  options.create_if_missing = true;
-  options.disable_auto_compactions = true;
-  DestroyAndReopen(options);
-
-  const std::string sst_path = dbname_ + "/embedded_resolve_err_wholevalue.sst";
-  SstFileWriterEmbeddedBlobOptions embedded_blob_options;
-  embedded_blob_options.min_blob_size = 8;
-
-  // A large whole value is stored as a same-file blob, so the table entry
-  // becomes a same-file (file number 0) BlobIndex (kTypeBlobIndex) -- the
-  // whole-value path whose resolution reads the blob region during compaction.
-  const std::string big_val(1024, 'b');
-
-  SstFileWriter writer(EnvOptions(), options);
-  ASSERT_OK(writer.OpenWithEmbeddedBlobs(sst_path, embedded_blob_options));
-  ASSERT_OK(writer.Put("k2", big_val));
-  ASSERT_OK(writer.Finish());
-  ASSERT_OK(db_->IngestExternalFile({sst_path}, IngestExternalFileOptions()));
-
-  // Add keys straddling the embedded blob so a real compaction (not a trivial
-  // move) reads and resolves it.
-  ASSERT_OK(Put("k1", "v1"));
-  ASSERT_OK(Put("k3", "v3"));
-  ASSERT_OK(Flush());
-
-  // Inject a resolution failure only during the compaction below, simulating a
-  // blob-region read fault.
-  const Status kInjected = Status::IOError("injected embedded blob read error");
-  SyncPoint::GetInstance()->SetCallBack(
-      "BlockBasedTable::MaybeResolveEmbeddedValue:InjectError",
-      [&](void* arg) { *static_cast<Status*>(arg) = kInjected; });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  const Status s = db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-
-  // The compaction must fail with the injected read error. Before the fix it
-  // instead succeeded (masking the error) and persisted a {kTypeValue, raw
-  // BlobIndex} record; it must not do that, and it must not report a misleading
-  // "Invalid blob file number" corruption either.
-  ASSERT_NOK(s);
-  EXPECT_TRUE(s.IsIOError()) << s.ToString();
-  EXPECT_EQ(s.ToString().find("Invalid blob file number"), std::string::npos)
-      << s.ToString();
-}
-
-// When a blob cache is configured, same-file ("embedded") blob reads should go
-// through BlobSource: the first read misses + inserts + does a disk read, and
-// the second read of the same blob is served from the blob cache. This holds on
-// both the Get() and the iterator paths.
-TEST_F(DBBlobIndexTest, EmbeddedBlobBlobCacheHitMiss) {
-  Options options = GetTestOptions();
-  options.create_if_missing = true;
-  options.statistics = CreateDBStatistics();
-
-  LRUCacheOptions co;
-  co.capacity = 8 << 20;
-  options.blob_cache = NewLRUCache(co);
-
-  DestroyAndReopen(options);
-
-  const std::string sst_path = dbname_ + "/embedded_cache.sst";
-  SstFileWriterEmbeddedBlobOptions embedded_blob_options;
-  embedded_blob_options.min_blob_size = 8;
-
-  const std::string big1(1024, 'x');
-  const std::string big2(1024, 'y');
-
-  SstFileWriter writer(EnvOptions(), options);
-  ASSERT_OK(writer.OpenWithEmbeddedBlobs(sst_path, embedded_blob_options));
-  ASSERT_OK(writer.Put("k1", big1));
-  ASSERT_OK(writer.Put("k2", big2));
-  ASSERT_OK(writer.Finish());
-
-  ASSERT_OK(db_->IngestExternalFile({sst_path}, IngestExternalFileOptions()));
-
-  Statistics* const stats = options.statistics.get();
-
-  // First Get: blob cache miss -> disk read -> cache insert.
-  ASSERT_OK(stats->Reset());
-  get_perf_context()->Reset();
-  SetPerfLevel(kEnableCount);
-  ASSERT_EQ(Get("k1"), big1);
-  EXPECT_EQ(stats->getTickerCount(BLOB_DB_CACHE_MISS), 1);
-  EXPECT_EQ(stats->getTickerCount(BLOB_DB_CACHE_HIT), 0);
-  EXPECT_EQ(stats->getTickerCount(BLOB_DB_CACHE_ADD), 1);
-  EXPECT_GT(stats->getTickerCount(BLOB_DB_BLOB_FILE_BYTES_READ), 0);
-  EXPECT_EQ(get_perf_context()->blob_read_count, 1);
-
-  // Second Get of the same key: blob cache hit, no disk read, no insert.
-  ASSERT_OK(stats->Reset());
-  get_perf_context()->Reset();
-  ASSERT_EQ(Get("k1"), big1);
-  EXPECT_EQ(stats->getTickerCount(BLOB_DB_CACHE_HIT), 1);
-  EXPECT_EQ(stats->getTickerCount(BLOB_DB_CACHE_MISS), 0);
-  EXPECT_EQ(stats->getTickerCount(BLOB_DB_CACHE_ADD), 0);
-  EXPECT_EQ(stats->getTickerCount(BLOB_DB_BLOB_FILE_BYTES_READ), 0);
-  EXPECT_EQ(get_perf_context()->blob_read_count, 0);
-  EXPECT_EQ(get_perf_context()->blob_cache_hit_count, 1);
-
-  // Iterator path: first read of a fresh key misses + inserts.
-  ASSERT_OK(stats->Reset());
-  {
-    std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
-    iter->Seek("k2");
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_OK(iter->status());
-    EXPECT_EQ(iter->value(), big2);
-  }
-  EXPECT_EQ(stats->getTickerCount(BLOB_DB_CACHE_MISS), 1);
-  EXPECT_EQ(stats->getTickerCount(BLOB_DB_CACHE_ADD), 1);
-
-  // Iterator path: second read of the same key hits the blob cache.
-  ASSERT_OK(stats->Reset());
-  {
-    std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
-    iter->Seek("k2");
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_OK(iter->status());
-    EXPECT_EQ(iter->value(), big2);
-  }
-  EXPECT_EQ(stats->getTickerCount(BLOB_DB_CACHE_HIT), 1);
-  EXPECT_EQ(stats->getTickerCount(BLOB_DB_CACHE_ADD), 0);
-
-  SetPerfLevel(kDisable);
-}
-
-// With the blob cache and block cache pointing at the same Cache, the SST-like
-// cache-key scheme (offset >> 2 on the SST's base key) keeps embedded blob
-// records disjoint from the SST's data blocks. Reading embedded blobs must not
-// alias or evict data blocks, and values must remain correct.
-TEST_F(DBBlobIndexTest, EmbeddedBlobSharedBlockAndBlobCache) {
-  Options options = GetTestOptions();
-  options.create_if_missing = true;
-  options.statistics = CreateDBStatistics();
-
-  LRUCacheOptions co;
-  co.capacity = 16 << 20;
-  auto shared_cache = NewLRUCache(co);
-  options.blob_cache = shared_cache;
-
-  BlockBasedTableOptions bbto;
-  bbto.block_cache = shared_cache;
-  bbto.cache_index_and_filter_blocks = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
-
-  DestroyAndReopen(options);
-
-  const std::string sst_path = dbname_ + "/embedded_shared.sst";
-  SstFileWriterEmbeddedBlobOptions embedded_blob_options;
-  embedded_blob_options.min_blob_size = 8;
-
-  const std::string big1(1024, 'x');
-  const std::string big2(1024, 'y');
-
-  SstFileWriter writer(EnvOptions(), options);
-  ASSERT_OK(writer.OpenWithEmbeddedBlobs(sst_path, embedded_blob_options));
-  ASSERT_OK(writer.Put("k1", big1));
-  ASSERT_OK(writer.Put("k2", big2));
-  ASSERT_OK(writer.Finish());
-
-  ASSERT_OK(db_->IngestExternalFile({sst_path}, IngestExternalFileOptions()));
-
-  Statistics* const stats = options.statistics.get();
-
-  // Values are correct with a shared cache, and re-reads hit both the block
-  // cache (data blocks) and the blob cache (embedded payloads) independently.
-  ASSERT_EQ(Get("k1"), big1);
-  ASSERT_EQ(Get("k2"), big2);
-  ASSERT_EQ(Get("k1"), big1);
-  ASSERT_EQ(Get("k2"), big2);
-  EXPECT_GT(stats->getTickerCount(BLOB_DB_CACHE_HIT), 0);
-  EXPECT_GT(stats->getTickerCount(BLOCK_CACHE_HIT), 0);
-
-  // Iterator yields correct values too.
-  std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
-  iter->SeekToFirst();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_OK(iter->status());
-  EXPECT_EQ(iter->key(), "k1");
-  EXPECT_EQ(iter->value(), big1);
-
-  iter->Next();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_OK(iter->status());
-  EXPECT_EQ(iter->key(), "k2");
-  EXPECT_EQ(iter->value(), big2);
-
-  iter->Next();
-  ASSERT_FALSE(iter->Valid());
-  ASSERT_OK(iter->status());
-}
-
 class PlainBlobValueFilterV3 : public CompactionFilter {
 public:
  PlainBlobValueFilterV3(std::atomic<int>* filter_call_count,
@@ -2642,7 +2138,7 @@ TEST_F(DBBlobIndexTest, EntityBlobFilterV3Remove) {
      db_->PutEntity(WriteOptions(), db_->DefaultColumnFamily(), key, columns));
  ASSERT_OK(Flush());

-  // Compact to trigger the filter -- entity should be removed
+  // Compact to trigger the filter — entity should be removed
  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));

  // Key should be gone
@@ -0,0 +1,621 @@
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+
+#include "db/blog/blog_format.h"
+
+#include <cassert>
+#include <cstring>
+
+#include "env/unique_id_gen.h"
+#include "table/format.h"
+#include "table/unique_id_impl.h"
+#include "util/coding.h"
+#include "util/fastrange.h"
+#include "util/xxhash.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+// --- Property encoding/decoding ---
+
+void EncodeBlogProperties(const BlogPropertyMap& props, std::string* dst) {
+  for (const auto& [name, value] : props) {
+    PutLengthPrefixedSlice(dst, name);
+    PutLengthPrefixedSlice(dst, value);
+  }
+}
+
+Status DecodeBlogProperties(Slice* input, BlogPropertyMap* props) {
+  while (input->size() > 0) {
+    Slice name_slice;
+    Slice value_slice;
+    if (!GetLengthPrefixedSlice(input, &name_slice)) {
+      return Status::Corruption("Blog properties: truncated property name");
+    }
+    if (!GetLengthPrefixedSlice(input, &value_slice)) {
+      return Status::Corruption("Blog properties: truncated property value");
+    }
+    props->emplace_back(name_slice.ToString(), value_slice.ToString());
+  }
+  return Status::OK();
+}
+
+// --- BlogFileHeader ---
+
+uint32_t BlogFileHeader::incarnation_id() const {
+  return DecodeFixed32(escape_sequence);
+}
+
+void BlogFileHeader::EncodeTo(std::string* dst) const {
+  // --- Fixed header (40 bytes) ---
+  // Bytes [0-11]: File magic
+  dst->append(kBlogFileMagic, kBlogFileMagicSize);
+  // Byte [12]: Schema version
+  dst->push_back(static_cast<char>(schema_version));
+  // Byte [13]: Checksum type
+  dst->push_back(static_cast<char>(checksum_type));
+  // Byte [14]: Compact record type
+  dst->push_back(static_cast<char>(compact_record_type));
+  // Byte [15]: Flags
+  dst->push_back(static_cast<char>(flags));
+  // Bytes [16-25]: Escape sequence
+  dst->append(escape_sequence, kBlogEscapeSequenceSize);
+  // Bytes [26-31]: Reserved
+  for (int i = 0; i < 6; ++i) {
+    dst->push_back(0);
+  }
+
+  // Encode properties into a temporary buffer to measure size.
+  std::string prop_buf;
+  EncodeBlogProperties(properties, &prop_buf);
+  char prop_comp_type = static_cast<char>(kNoCompression);
+
+  // Build property section: [properties][compression_type][checksum]
+  uint32_t prop_checksum = ComputeBuiltinChecksumWithLastByte(
+      checksum_type, prop_buf.data(), prop_buf.size(), prop_comp_type);
+  prop_checksum +=
+      ChecksumModifierForContext(incarnation_id(), kBlogFileFixedHeaderSize);
+  std::string prop_section = std::move(prop_buf);
+  prop_section.push_back(prop_comp_type);
+  PutFixed32(&prop_section, prop_checksum);
+
+  // Bytes [32-35]: Property section size (trailer included, no padding)
+  PutFixed32(dst, static_cast<uint32_t>(prop_section.size()));
+
+  // Bytes [36-39]: Fixed header checksum (covers bytes [0, 36))
+  // Uses context checksum with incarnation_id at offset 0 for
+  // defense-in-depth (misplaced data detection).
+  assert(dst->size() == 36);
+  uint32_t header_checksum =
+      ComputeBuiltinChecksum(checksum_type, dst->data(), dst->size()) +
+      ChecksumModifierForContext(incarnation_id(), 0);
+  PutFixed32(dst, header_checksum);
+
+  // Property section follows the fixed header
+  assert(dst->size() == kBlogFileFixedHeaderSize);
+  dst->append(prop_section);
+}
+
+Status BlogFileHeader::DecodeFrom(Slice* input) {
+  if (input->size() < kBlogFileFixedHeaderSize) {
+    return Status::Corruption("Blog header too short: have " +
+                              std::to_string(input->size()) + " bytes, need " +
+                              std::to_string(kBlogFileFixedHeaderSize));
+  }
+
+  const char* p = input->data();
+
+  // Verify magic
+  if (memcmp(p, kBlogFileMagic, kBlogFileMagicSize) != 0) {
+    return Status::Corruption("Blog header: bad magic (first 4 bytes: 0x" +
+                              Slice(p, 4).ToString(true) + ")");
+  }
+
+  // Parse fields needed for checksum computation before verifying.
+  checksum_type = static_cast<ChecksumType>(p[13]);
+  memcpy(escape_sequence, p + 16, kBlogEscapeSequenceSize);
+
+  // Verify fixed header checksum FIRST, before trusting any other fields.
+  uint32_t prop_section_size = DecodeFixed32(p + 32);
+  uint32_t stored_header_checksum = DecodeFixed32(p + 36);
+  uint32_t computed_header_checksum =
+      ComputeBuiltinChecksum(checksum_type, p, 36) +
+      ChecksumModifierForContext(incarnation_id(), 0);
+  if (stored_header_checksum != computed_header_checksum) {
+    return Status::Corruption(
+        "Blog header: fixed header checksum mismatch (stored: 0x" +
+        Slice(p + 36, 4).ToString(true) + ", computed: 0x" +
+        Slice(reinterpret_cast<const char*>(&computed_header_checksum), 4)
+            .ToString(true) +
+        ")");
+  }
+
+  // Now that checksum is verified, validate the remaining fields.
+  schema_version = static_cast<uint8_t>(p[12]);
+  if (schema_version > kBlogCurrentSchemaVersion) {
+    return Status::NotSupported("Blog header: schema version " +
+                                std::to_string(schema_version) +
+                                " is newer than supported version " +
+                                std::to_string(kBlogCurrentSchemaVersion));
+  }
+  compact_record_type = static_cast<BlogRecordType>(p[14]);
+  flags = static_cast<uint8_t>(p[15]);
+
+  if (!VerifyEscapeSequence(escape_sequence)) {
+    return Status::Corruption(
+        "Blog header: escape sequence derived bytes mismatch (first byte: 0x" +
+        Slice(escape_sequence, 1).ToString(true) + ")");
+  }
+
+  // Advance past fixed header
+  input->remove_prefix(kBlogFileFixedHeaderSize);
+
+  // Read property section
+  if (input->size() < prop_section_size) {
+    return Status::Corruption("Blog header: truncated property section (have " +
+                              std::to_string(input->size()) + " bytes, need " +
+                              std::to_string(prop_section_size) + ")");
+  }
+
+  if (prop_section_size < kBlogBlockTrailerSize) {
+    return Status::Corruption("Blog header: property section too small (" +
+                              std::to_string(prop_section_size) +
+                              " bytes, min " +
+                              std::to_string(kBlogBlockTrailerSize) + ")");
+  }
+
+  // Property section layout: [properties][comp_type:1B][checksum:4B]
+  const char* prop_data = input->data();
+  size_t prop_data_size = prop_section_size - kBlogBlockTrailerSize;
+  char prop_comp_type = prop_data[prop_data_size];
+  uint32_t stored_prop_checksum = DecodeFixed32(prop_data + prop_data_size + 1);
+  uint32_t computed_prop_checksum = ComputeBuiltinChecksumWithLastByte(
+      checksum_type, prop_data, prop_data_size, prop_comp_type);
+  computed_prop_checksum +=
+      ChecksumModifierForContext(incarnation_id(), kBlogFileFixedHeaderSize);
+  if (stored_prop_checksum != computed_prop_checksum) {
+    return Status::Corruption(
+        "Blog header: property section checksum mismatch (prop_size=" +
+        std::to_string(prop_data_size) + ", comp_type=0x" +
+        Slice(&prop_comp_type, 1).ToString(true) + ")");
+  }
+
+  // Decode properties
+  Slice prop_slice(prop_data, prop_data_size);
+  properties.clear();
+  Status s = DecodeBlogProperties(&prop_slice, &properties);
+  if (!s.ok()) {
+    return s;
+  }
+
+  // Check for unrecognized required properties
+  for (const auto& [name, value] : properties) {
+    if (IsBlogRequiredProperty(name)) {
+      if (name != kBlogPropCompressionCompatibilityName &&
+          name != kBlogPropTimestampSize &&
+          name != kBlogPropPredecessorWalInfo &&
+          name != kBlogPropWriteBatchStreamingCompressionType) {
+        return Status::NotSupported(
+            "Blog header: unrecognized required property: \"" + name + "\"");
+      }
+    }
+  }
+
+  input->remove_prefix(prop_section_size);
+  return Status::OK();
+}
+
+void BlogFileHeader::SetEscapeSequenceFromU64(uint64_t v) {
+  // Byte 0: derived from top 4 bytes via FastRange32 into [1, 254],
+  // avoiding 0x00 and 0xFF (which are padding bytes).
+  uint32_t top = static_cast<uint32_t>(v >> 32);
+  escape_sequence[0] = static_cast<char>(FastRange32(top, 254) + 1);
+  assert(escape_sequence[0] != '\0');
+  assert(escape_sequence[0] != '\xFF');
+
+  // Bytes 1-5: lowest 5 bytes as-is (little-endian).
+  EncodeFixed32(escape_sequence + 1, static_cast<uint32_t>(v));
+  escape_sequence[5] = static_cast<char>(v >> 32);
+  // (byte at index 5 overlaps with top byte used for FastRange32, but
+  // that's fine -- it's just input entropy, not the derived byte 0)
+
+  // Bytes 6-9: XXH3-derived suffix for heuristic detection. This would enable
+  // us to scan through a file missing its header and, with some hashing effort,
+  // detect escape sequences with high accuracy (expect 1 false positive per
+  // ~16GB; further validation/pruning can be done trying to parse records
+  // and/or picking the most common candidate escape sequence).
+  uint64_t derived = XXH3_64bits_withSeed(
+      escape_sequence, kBlogEscapeSeqRandomPartSize, kBlogEscapeSeqSeed);
+  EncodeFixed32(escape_sequence + kBlogEscapeSeqRandomPartSize,
+                static_cast<uint32_t>(derived));
+}
+
+void BlogFileHeader::GenerateFromUniqueId(const std::string& db_id,
+                                          const std::string& db_session_id,
+                                          uint64_t file_number) {
+  if (db_id.empty() || db_session_id.empty() || file_number == 0) {
+    GenerateRandomFields();
+    return;
+  }
+
+  // Derive escape sequence from the same unique ID scheme as SST files.
+  UniqueId64x2 unique_id;
+  Status s =
+      GetSstInternalUniqueId(db_id, db_session_id, file_number, &unique_id);
+  if (!s.ok()) {
+    GenerateRandomFields();
+    return;
+  }
+
+  // The internal unique ID is intentionally not fully random/mixed. Mix it
+  // so that it is.
+  InternalUniqueIdToExternal(&unique_id);
+
+  SetEscapeSequenceFromU64(unique_id[0]);
+
+  // Store the inputs as ignorable header properties for debugging/tracking.
+  SetProperty(kBlogPropDbId, db_id);
+  SetProperty(kBlogPropDbSessionId, db_session_id);
+  SetUint64Property(kBlogPropFileNumber, file_number);
+}
+
+void BlogFileHeader::GenerateRandomFields() {
+  uint64_t rand_a;
+  uint64_t rand_b;
+  GenerateRawUniqueId(&rand_a, &rand_b);
+  // Use rand_a for escape sequence, rand_b is unused extra entropy.
+  (void)rand_b;
+  SetEscapeSequenceFromU64(rand_a);
+}
+
+bool BlogFileHeader::VerifyEscapeSequence(const char* seq) {
+  uint8_t first = static_cast<uint8_t>(seq[0]);
+  if (first == 0x00 || first == 0xFF) {
+    return false;
+  }
+  // Verify derived part
+  uint64_t derived = XXH3_64bits_withSeed(seq, kBlogEscapeSeqRandomPartSize,
+                                          kBlogEscapeSeqSeed);
+  uint32_t expected = static_cast<uint32_t>(derived);
+  uint32_t actual = DecodeFixed32(seq + kBlogEscapeSeqRandomPartSize);
+  return expected == actual;
+}
+
+void BlogFileHeader::SetProperty(const std::string& name,
+                                 const std::string& value) {
+  for (auto& [k, v] : properties) {
+    if (k == name) {
+      v = value;
+      return;
+    }
+  }
+  properties.emplace_back(name, value);
+}
+
+std::string BlogFileHeader::GetProperty(const std::string& name) const {
+  for (const auto& [k, v] : properties) {
+    if (k == name) {
+      return v;
+    }
+  }
+  return "";
+}
+
+bool BlogFileHeader::HasProperty(const std::string& name) const {
+  for (const auto& [k, v] : properties) {
+    if (k == name) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void BlogFileHeader::SetUint64Property(const std::string& name,
+                                       uint64_t value) {
+  std::string encoded;
+  PutVarint64(&encoded, value);
+  SetProperty(name, encoded);
+}
+
+void BlogFileHeader::SetUint32Property(const std::string& name,
+                                       uint32_t value) {
+  std::string encoded;
+  PutVarint32(&encoded, value);
+  SetProperty(name, encoded);
+}
+
+bool BlogFileHeader::GetUint64Property(const std::string& name,
+                                       uint64_t* value) const {
+  std::string raw = GetProperty(name);
+  if (raw.empty()) {
+    return false;
+  }
+  Slice s(raw);
+  return GetVarint64(&s, value);
+}
+
+bool BlogFileHeader::GetUint32Property(const std::string& name,
+                                       uint32_t* value) const {
+  std::string raw = GetProperty(name);
+  if (raw.empty()) {
+    return false;
+  }
+  Slice s(raw);
+  return GetVarint32(&s, value);
+}
+
+Status BlogFileHeader::DecodeFromBuffer(Slice* buffer,
+                                        size_t* additional_bytes_needed) {
+  if (buffer->size() < kBlogFileFixedHeaderSize) {
+    return Status::Corruption("Blog header: buffer too small for fixed header");
+  }
+
+  // Check if the full header (fixed + property section) fits in the buffer.
+  uint32_t prop_section_size = DecodeFixed32(buffer->data() + 32);
+  size_t total_header_size = kBlogFileFixedHeaderSize + prop_section_size;
+
+  if (buffer->size() < total_header_size) {
+    if (additional_bytes_needed) {
+      *additional_bytes_needed = total_header_size - buffer->size();
+    }
+    return Status::Incomplete(
+        "Blog header: need more data for property section",
+        std::to_string(total_header_size));
+  }
+
+  // Full header is available. Decode it.
+  Slice header_slice(buffer->data(), total_header_size);
+  Status s = DecodeFrom(&header_slice);
+  if (s.ok()) {
+    buffer->remove_prefix(total_header_size);
+  }
+  return s;
+}
+
+// --- Footer locator verification ---
+
+bool VerifyBlogFooterLocator(const char* buffer, size_t buffer_size,
+                             uint64_t buffer_file_offset,
+                             const char* expected_escape_seq,
+                             ChecksumType checksum_type,
+                             uint32_t incarnation_id) {
+  // Scan backward in 4-byte steps for the escape sequence.
+  // Buffer must start at a 4-byte-aligned file offset.
+  for (size_t pos = buffer_size; pos >= 4; pos -= 4) {
+    size_t esc_start = pos - 4;
+    uint8_t first_byte = static_cast<uint8_t>(buffer[esc_start]);
+    if (first_byte == 0x00 || first_byte == 0xFF) {
+      continue;  // padding byte
+    }
+    // Check if this is our escape sequence
+    if (esc_start + kBlogEscapeSequenceSize > buffer_size ||
+        memcmp(buffer + esc_start, expected_escape_seq,
+               kBlogEscapeSequenceSize) != 0) {
+      continue;  // not our escape sequence
+    }
+
+    // Found escape sequence. Parse the full-format record that follows.
+    // Full format: [escape_seq:10B] [varint length:4+B] [type:1B]
+    //              [compression_type:1B] [prefix_checksum:4B]
+    //              [payload:length B] [comp:1B] [checksum:4B]
+    const char* rec = buffer + esc_start + kBlogEscapeSequenceSize;
+    size_t remaining = buffer_size - esc_start - kBlogEscapeSequenceSize;
+
+    // Parse varint length (must be >= 4 bytes for full format)
+    Slice varint_slice(rec, remaining);
+    uint64_t length = 0;
+    const char* varint_end = GetVarint64Ptr(rec, rec + remaining, &length);
+    if (!varint_end) {
+      continue;  // truncated varint
+    }
+    size_t varint_len = static_cast<size_t>(varint_end - rec);
+    if (varint_len <= kBlogCompactVarintMaxBytes) {
+      continue;  // not full format
+    }
+
+    // Need type(1) + comp(1) + prefix_checksum(4) after varint
+    size_t after_varint = remaining - varint_len;
+    if (after_varint < 6) {
+      continue;  // truncated prefix
+    }
+
+    BlogRecordType type =
+        static_cast<BlogRecordType>(static_cast<uint8_t>(varint_end[0]));
+    if (type != kBlogFooterLocatorRecord) {
+      continue;  // not a footer locator
+    }
+
+    // Verify prefix checksum over (varint + type + compression_type)
+    size_t prefix_data_size = varint_len + 2;  // varint + type + comp
+    uint64_t esc_file_offset = buffer_file_offset + esc_start;
+    uint32_t stored_prefix_checksum = DecodeFixed32(varint_end + 2);
+    uint32_t computed_prefix_checksum =
+        ComputeBuiltinChecksum(checksum_type, rec, prefix_data_size) +
+        ChecksumModifierForContext(incarnation_id, esc_file_offset);
+    if (stored_prefix_checksum != computed_prefix_checksum) {
+      continue;  // prefix checksum mismatch
+    }
+
+    // If length > 0, verify the payload trailer checksum
+    if (length > 0) {
+      size_t after_prefix = after_varint - 6;  // after type+comp+prefix_cksum
+      if (after_prefix < length + kBlogBlockTrailerSize) {
+        continue;  // truncated payload or trailer
+      }
+      const char* payload = varint_end + 6;
+      uint64_t payload_file_offset = buffer_file_offset + esc_start +
+                                     kBlogEscapeSequenceSize + varint_len + 6;
+      CompressionType actual_comp;
+      Status s = VerifyBlogRecordTrailer(
+          checksum_type, payload, static_cast<size_t>(length), incarnation_id,
+          payload_file_offset, &actual_comp);
+      if (!s.ok()) {
+        continue;  // trailer checksum mismatch
+      }
+    }
+
+    // Valid footer locator record found.
+    return true;
+  }
+  return false;
+}
+
+// --- BlogFileFooterLocator ---
+
+void BlogFileFooterLocator::EncodeTo(std::string* dst) const {
+  for (const auto& entry : entries) {
+    dst->push_back(static_cast<char>(entry.record_type));
+    PutFixed32(dst, entry.relative_offset_4B);
+  }
+}
+
+Status BlogFileFooterLocator::DecodeFrom(const Slice& input) {
+  Slice s = input;
+  entries.clear();
+  while (s.size() >= 5) {  // 1 byte type + 4 bytes offset
+    entries.push_back(
+        {.record_type = static_cast<BlogRecordType>(static_cast<uint8_t>(s[0])),
+         .relative_offset_4B = DecodeFixed32(s.data() + 1)});
+    s.remove_prefix(5);
+  }
+  if (s.size() != 0) {
+    return Status::Corruption(
+        "Blog footer locator: trailing bytes after entries");
+  }
+  return Status::OK();
+}
+
+// --- BlogFileFooterProperties ---
+
+void BlogFileFooterProperties::SetBlobCount(uint64_t count) {
+  std::string val;
+  PutVarint64(&val, count);
+  properties.emplace_back("blobCount", std::move(val));
+}
+
+void BlogFileFooterProperties::SetTotalBlobBytes(uint64_t bytes) {
+  std::string val;
+  PutVarint64(&val, bytes);
+  properties.emplace_back("totalBlobBytes", std::move(val));
+}
+
+void BlogFileFooterProperties::SetSequenceRange(uint64_t min_seq,
+                                                uint64_t max_seq) {
+  std::string min_val;
+  PutVarint64(&min_val, min_seq);
+  properties.emplace_back("minSequence", std::move(min_val));
+  std::string max_val;
+  PutVarint64(&max_val, max_seq);
+  properties.emplace_back("maxSequence", std::move(max_val));
+}
+
+void BlogFileFooterProperties::EncodeTo(std::string* dst) const {
+  EncodeBlogProperties(properties, dst);
+}
+
+Status BlogFileFooterProperties::DecodeFrom(const Slice& input) {
+  Slice s = input;
+  properties.clear();
+  return DecodeBlogProperties(&s, &properties);
+}
+
+// --- Padding ---
+
+void ComputeBlogPaddingParams(uint8_t last_meaningful_byte,
+                              size_t current_offset, uint8_t* pad_byte,
+                              size_t* pad_count) {
+  // Determine how many bytes needed to reach next 4-byte alignment
+  size_t remainder = current_offset % 4;
+  size_t needed = (remainder == 0) ? 0 : (4 - remainder);
+
+  // Choose pad byte to differ from last_meaningful_byte
+  if (last_meaningful_byte == 0x00) {
+    *pad_byte = 0xFF;
+    // Must have at least 1 byte of padding to distinguish from checksum
+    if (needed == 0) {
+      needed = 4;
+    }
+  } else if (last_meaningful_byte == 0xFF) {
+    *pad_byte = 0x00;
+    if (needed == 0) {
+      needed = 4;
+    }
+  } else {
+    *pad_byte = 0x00;  // Writer's choice; 0x00 is conventional
+  }
+  *pad_count = needed;
+}
+
+void ComputeBlogPadding(uint8_t last_meaningful_byte, size_t current_offset,
+                        std::string* dst) {
+  uint8_t pad_byte;
+  size_t pad_count;
+  ComputeBlogPaddingParams(last_meaningful_byte, current_offset, &pad_byte,
+                           &pad_count);
+  dst->append(pad_count, static_cast<char>(pad_byte));
+}
+
+// --- Checksum ---
+
+uint32_t ComputeBlogRecordChecksum(ChecksumType type, const char* data,
+                                   size_t data_size, char compression_type_byte,
+                                   uint32_t base_context_checksum,
+                                   uint64_t record_offset) {
+  uint32_t checksum = ComputeBuiltinChecksumWithLastByte(type, data, data_size,
+                                                         compression_type_byte);
+  checksum += ChecksumModifierForContext(base_context_checksum, record_offset);
+  return checksum;
+}
+
+// --- Record trailer verification ---
+
+Status VerifyBlogRecordTrailer(ChecksumType checksum_type, const char* payload,
+                               size_t payload_size, uint32_t incarnation_id,
+                               uint64_t payload_file_offset,
+                               CompressionType* actual_compression_type) {
+  // Trailer is the 5 bytes immediately after the payload:
+  // [compression_type: 1B][checksum: 4B]
+  const char* trailer = payload + payload_size;
+  char comp_byte = trailer[0];
+  uint32_t stored_checksum = DecodeFixed32(trailer + 1);
+  uint32_t computed_checksum =
+      ComputeBlogRecordChecksum(checksum_type, payload, payload_size, comp_byte,
+                                incarnation_id, payload_file_offset);
+  if (stored_checksum != computed_checksum) {
+    return Status::Corruption("Blog record checksum mismatch");
+  }
+  if (actual_compression_type) {
+    *actual_compression_type =
+        static_cast<CompressionType>(static_cast<uint8_t>(comp_byte));
+  }
+  return Status::OK();
+}
+
+// --- Irregular varint ---
+
+void PutBlogIrregularVarint64(std::string* dst, uint64_t value,
+                              size_t min_encoded_bytes) {
+  // Encode as standard varint, then pad with trailing zero-data bytes
+  // to reach min_encoded_bytes. The result decodes to the same value.
+  char buf[10];
+  char* end = EncodeVarint64(buf, value);
+  size_t natural_len = static_cast<size_t>(end - buf);
+
+  if (natural_len >= min_encoded_bytes) {
+    dst->append(buf, natural_len);
+    return;
+  }
+
+  // Set the continuation bit on what was the terminal byte, then append
+  // (extra - 1) continuation bytes (0x80) and one terminal byte (0x00).
+  size_t extra = min_encoded_bytes - natural_len;
+  buf[natural_len - 1] |= static_cast<char>(0x80);
+  dst->append(buf, natural_len);
+  for (size_t i = 0; i + 1 < extra; ++i) {
+    dst->push_back(static_cast<char>(0x80));
+  }
+  dst->push_back(static_cast<char>(0x00));
+}
+
+}  // namespace ROCKSDB_NAMESPACE
@@ -0,0 +1,299 @@
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "rocksdb/rocksdb_namespace.h"
+#include "rocksdb/slice.h"
+#include "rocksdb/status.h"
+#include "rocksdb/table.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+// Record types used in blog file body and footer.
+// Types 0x01-0x7F are for body records.
+// Types 0xF0-0xFF are for footer records (in expected order of occurrence,
+// with gaps for future additions).
+enum BlogRecordType : uint8_t {
+  kBlogBlobRecord = 0x01,
+  kBlogPreambleStartRecord = 0x02,
+  kBlogWriteBatchRecord = 0x03,
+  // 0x04-0x7F: reserved for future body record types
+
+  kBlogFooterIndexRecord = 0xF0,  // sparse index or similar large metadata
+  // 0xF1-0xF3: reserved for future footer data records
+  kBlogFooterPropertiesRecord = 0xF8,  // small metadata (named properties)
+  // 0xF9-0xFB: reserved
+  kBlogFooterFileChecksumInfo = 0xFC,  // full file checksum state dump, so
+                                       // the file checksum can be inferred
+                                       // from just reading the tail
+  // 0xFD-0xFE: reserved
+  kBlogFooterLocatorRecord = 0xFF,  // relative offsets to other footer
+                                    // records; must be last
+};
+
+// --- Constants ---
+
+// 12-byte file magic: "Blog" (ASCII) followed by XXH3_64bits("Blog", 4).
+// Used as an opaque identifier for blog format files.
+static constexpr char kBlogFileMagic[12] = {
+    '\x42', '\x6C', '\x6F', '\x67',                                 // "Blog"
+    '\x9F', '\xFC', '\x41', '\x52', '\xF7', '\xF2', '\x2C', '\x49'  // XXH3_64
+};
+static constexpr size_t kBlogFileMagicSize = 12;
+
+// Fixed header size in bytes (before property section).
+static constexpr size_t kBlogFileFixedHeaderSize = 40;
+
+// Escape sequence: 6 random bytes + 4 derived bytes.
+static constexpr size_t kBlogEscapeSequenceSize = 10;
+static constexpr size_t kBlogEscapeSeqRandomPartSize = 6;
+
+// Seed for deriving bytes [6-9] of escape sequence via
+// XXH3_64bits_withSeed(random_6_bytes, 6, kBlogEscapeSeqSeed).
+// Chosen arbitrarily; must never change once the format is released.
+static constexpr uint64_t kBlogEscapeSeqSeed =
+    0x52636B73426C6F67ULL;  // "RcksBlg\0"
+
+// Sentinel for unspecified-size records. Encodes to a 9-byte varint,
+// which always triggers the full record format.
+static constexpr uint64_t kBlogUnspecifiedSize = (uint64_t{1} << 63) - 1;
+
+// Maximum payload size that encodes to a compact-format varint (<= 2 bytes).
+// varint of 16383 (0x3FFF) uses 2 bytes; 16384 uses 3 bytes.
+// Records larger than this get full format with prefix checksum protection.
+static constexpr uint64_t kBlogMaxCompactPayloadSize = (1u << 14) - 1;
+
+// Compact format varint threshold: varints of this many bytes or fewer
+// use compact format (no type byte, no prefix checksum).
+static constexpr size_t kBlogCompactVarintMaxBytes = 2;
+
+// Block trailer size: 1 byte compression_type + 4 bytes checksum.
+static constexpr size_t kBlogBlockTrailerSize = 5;
+
+// kStreamingCompressionSentinel (0x7F) is defined in compression_type.h
+// and used in blog record trailers to indicate streaming compression.
+// A record with kNoCompression in the trailer remains individually
+// uncompressed even when streaming is active (dynamic on/off).
+
+// --- Named Properties ---
+
+// Named property: string key -> string value.
+// Case convention: Uppercase first letter = required (reader must recognize
+// or reject the file). Lowercase first letter = ignorable.
+using BlogPropertyMap = std::vector<std::pair<std::string, std::string>>;
+
+// Encode properties as a sequence of length-prefixed name/value pairs.
+// No count prefix; section is terminated by reaching the end of the slice.
+void EncodeBlogProperties(const BlogPropertyMap& props, std::string* dst);
+
+// Decode properties from a slice, consuming all bytes.
+Status DecodeBlogProperties(Slice* input, BlogPropertyMap* props);
+
+// Returns true if a property name starts with an uppercase letter,
+// meaning the reader must recognize it or reject the file.
+inline bool IsBlogRequiredProperty(const Slice& name) {
+  return name.size() > 0 && name[0] >= 'A' && name[0] <= 'Z';
+}
+
+// Known header property names
+static constexpr const char* kBlogPropCompressionCompatibilityName =
+    "CompressionCompatibilityName";
+static constexpr const char* kBlogPropTimestampSize = "TimestampSize";
+static constexpr const char* kBlogPropPredecessorWalInfo = "PredecessorWalInfo";
+// Required (uppercase) when streaming compression is active for WriteBatch
+// records. Value is a 2-digit hex encoding of the CompressionType used
+// (e.g. "07" for kZSTD). The presence of this property means WriteBatch
+// record payloads with kStreamingCompressionSentinel in their trailer
+// are part of a streaming compression context that spans across records.
+static constexpr const char* kBlogPropWriteBatchStreamingCompressionType =
+    "WriteBatchStreamingCompressionType";
+static constexpr const char* kBlogPropRole = "role";
+static constexpr const char* kBlogPropCompressionSettings =
+    "compressionSettings";
+static constexpr const char* kBlogPropCreationTime = "creationTime";
+static constexpr const char* kBlogPropCreator = "creator";
+// Ignorable properties for file identity and diagnostics.
+static constexpr const char* kBlogPropDbId = "dbId";
+static constexpr const char* kBlogPropDbSessionId = "dbSessionId";
+static constexpr const char* kBlogPropFileNumber = "fileNumber";
+static constexpr const char* kBlogPropDbHostId = "dbHostId";
+static constexpr const char* kBlogPropColumnFamilyId = "columnFamilyId";
+static constexpr const char* kBlogPropColumnFamilyName = "columnFamilyName";
+
+// --- BlogFileHeader ---
+
+// Bit flags for BlogFileHeader::flags (byte [15] in the fixed header).
+enum BlogFileHeaderFlags : uint8_t {
+  kBlogFileRecycled = 0x01,  // File may contain trailing stale data from a
+                             // previous incarnation. Recovery should tolerate
+                             // trailing data that doesn't match our escape
+                             // sequence (recycled/stale, not corruption).
+};
+
+static constexpr uint8_t kBlogCurrentSchemaVersion = 0;
+
+struct BlogFileHeader {
+  uint8_t schema_version = kBlogCurrentSchemaVersion;
+  ChecksumType checksum_type = kXXH3;
+  BlogRecordType compact_record_type = kBlogBlobRecord;
+  uint8_t flags = 0;  // BlogFileHeaderFlags, byte [15] in fixed header
+  // 10-byte escape sequence: bytes [0-5] random (byte[0] not 0x00/0xFF),
+  // bytes [6-9] = lower32(XXH3_64bits_withSeed(bytes[0-5],
+  // kBlogEscapeSeqSeed)).
+  char escape_sequence[kBlogEscapeSequenceSize] = {};
+
+  bool is_recycled() const { return flags & kBlogFileRecycled; }
+
+  BlogPropertyMap properties;
+
+  // Incarnation ID = first 4 bytes of escape_sequence (little-endian via
+  // DecodeFixed32). Guaranteed nonzero since byte[0] is not 0x00.
+  uint32_t incarnation_id() const;
+
+  // Encode the full header (fixed prefix + property section + checksums)
+  // into dst.
+  void EncodeTo(std::string* dst) const;
+
+  // Decode from input. Consumes the bytes read.
+  Status DecodeFrom(Slice* input);
+
+  // Generate escape_sequence from the file's unique ID (db_id, db_session_id,
+  // file_number), using the same scheme as SST internal unique IDs. Falls back
+  // to GenerateRandomFields() if any input is empty/zero. Also sets the
+  // ignorable dbId/dbSessionId/fileNumber header properties.
+  void GenerateFromUniqueId(const std::string& db_id,
+                            const std::string& db_session_id,
+                            uint64_t file_number);
+
+  // Generate escape_sequence from random bytes. Appropriate when unique ID
+  // inputs are not available.
+  void GenerateRandomFields();
+
+ private:
+  // Populate escape_sequence from a 64 bits of entropy.
+  void SetEscapeSequenceFromU64(uint64_t v);
+
+ public:
+  // Verify that the escape sequence's derived bytes match.
+  static bool VerifyEscapeSequence(const char* seq);
+
+  // Check if a buffer starts with the blog file magic number.
+  static bool IsBlogFormat(const char* data, size_t size) {
+    return size >= kBlogFileMagicSize &&
+           memcmp(data, kBlogFileMagic, kBlogFileMagicSize) == 0;
+  }
+
+  // Decode a blog file header from a buffer that may or may not contain
+  // the full header. Returns OK and consumes the header bytes on success.
+  // If the buffer contains the fixed header but not the full property
+  // section, returns the number of additional bytes needed in
+  // *additional_bytes_needed and returns Status::Incomplete().
+  // This enables single-read header parsing from a ~4 KiB buffer.
+  Status DecodeFromBuffer(Slice* buffer, size_t* additional_bytes_needed);
+
+  // Raw property helpers (string values)
+  void SetProperty(const std::string& name, const std::string& value);
+  std::string GetProperty(const std::string& name) const;
+
+  // Typed property setters/getters for properties that aren't natively strings.
+  void SetUint64Property(const std::string& name, uint64_t value);
+  void SetUint32Property(const std::string& name, uint32_t value);
+  bool GetUint64Property(const std::string& name, uint64_t* value) const;
+  bool GetUint32Property(const std::string& name, uint32_t* value) const;
+  bool HasProperty(const std::string& name) const;
+};
+
+// --- Footer types ---
+
+// Entry in a footer locator record. Offsets are in units of 4 bytes,
+// sequential relative to each other in reverse order of footer records.
+// First entry: offset from locator's escape_seq to the preceding footer
+// record's escape_seq. Subsequent entries: offset from the previous
+// entry's escape_seq to the next earlier footer record's escape_seq.
+// Verify that a blog file's trailing data contains a valid footer locator
+// record. Scans backward from the end of the buffer for the escape sequence,
+// then parses and verifies the full record (varint length, type, prefix
+// checksum, payload, trailer checksum). The buffer must start at a 4-byte-
+// aligned file offset. Returns true if a valid footer locator record is found.
+bool VerifyBlogFooterLocator(const char* buffer, size_t buffer_size,
+                             uint64_t buffer_file_offset,
+                             const char* expected_escape_seq,
+                             ChecksumType checksum_type,
+                             uint32_t incarnation_id);
+
+struct BlogFooterLocatorEntry {
+  BlogRecordType record_type;
+  uint32_t relative_offset_4B;
+};
+
+struct BlogFileFooterLocator {
+  std::vector<BlogFooterLocatorEntry> entries;
+
+  // Encode as the payload of a footer locator record.
+  void EncodeTo(std::string* dst) const;
+  Status DecodeFrom(const Slice& input);
+};
+
+struct BlogFileFooterProperties {
+  BlogPropertyMap properties;
+
+  // Convenience setters that encode values into the property map.
+  void SetBlobCount(uint64_t count);
+  void SetTotalBlobBytes(uint64_t bytes);
+  void SetSequenceRange(uint64_t min_seq, uint64_t max_seq);
+
+  // Encode as named properties (no 5-byte trailer; that comes from
+  // the enclosing full record format).
+  void EncodeTo(std::string* dst) const;
+  Status DecodeFrom(const Slice& input);
+};
+
+// --- Padding helpers ---
+
+// Compute padding needed to reach the next 4-byte-aligned offset,
+// choosing the pad byte value to differ from last_meaningful_byte.
+// Appends padding bytes to dst.
+void ComputeBlogPadding(uint8_t last_meaningful_byte, size_t current_offset,
+                        std::string* dst);
+
+// Same as above, but returns the pad byte value and count without
+// allocating. For use on hot paths.
+void ComputeBlogPaddingParams(uint8_t last_meaningful_byte,
+                              size_t current_offset, uint8_t* pad_byte,
+                              size_t* pad_count);
+
+// --- Checksum helpers ---
+
+// Compute a context-aware checksum over data + compression_type byte,
+// suitable for a blog record trailer. Uses the same algorithm and context
+// checksum approach as block-based SST files.
+uint32_t ComputeBlogRecordChecksum(ChecksumType type, const char* data,
+                                   size_t data_size, char compression_type_byte,
+                                   uint32_t base_context_checksum,
+                                   uint64_t record_offset);
+
+// Verify a blog record's 5-byte trailer (compression_type + checksum).
+// payload points to the record payload of payload_size bytes; the trailer
+// immediately follows. Returns OK if checksum matches, Corruption otherwise.
+// On success, *actual_compression_type is set from the trailer.
+Status VerifyBlogRecordTrailer(ChecksumType checksum_type, const char* payload,
+                               size_t payload_size, uint32_t incarnation_id,
+                               uint64_t payload_file_offset,
+                               CompressionType* actual_compression_type);
+
+// Encode an irregular varint: a value encoded with more bytes than the
+// minimum required, ensuring varint length > 3 bytes to trigger full
+// record format. The value is encoded correctly and will decode to the
+// same value via standard GetVarint64.
+void PutBlogIrregularVarint64(std::string* dst, uint64_t value,
+                              size_t min_encoded_bytes);
+
+}  // namespace ROCKSDB_NAMESPACE
@@ -0,0 +1,539 @@
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+
+#include "db/blog/blog_format.h"
+
+#include <cstdint>
+#include <cstring>
+#include <string>
+
+#include "table/format.h"
+#include "test_util/testharness.h"
+#include "util/coding.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+class BlogFormatTest : public testing::Test {};
+
+// --- Property encoding/decoding ---
+
+TEST_F(BlogFormatTest, EncodeDecodePropertiesEmpty) {
+  BlogPropertyMap props;
+  std::string encoded;
+  EncodeBlogProperties(props, &encoded);
+  ASSERT_EQ(encoded.size(), 0u);
+
+  BlogPropertyMap decoded;
+  Slice input(encoded);
+  ASSERT_OK(DecodeBlogProperties(&input, &decoded));
+  ASSERT_TRUE(decoded.empty());
+}
+
+TEST_F(BlogFormatTest, EncodeDecodePropertiesMultiple) {
+  BlogPropertyMap props = {
+      {"CompressionCompatibilityName", "zstd"},
+      {"role", "wal"},
+      {"compressionSettings", "level=3"},
+  };
+  std::string encoded;
+  EncodeBlogProperties(props, &encoded);
+  ASSERT_GT(encoded.size(), 0u);
+
+  BlogPropertyMap decoded;
+  Slice input(encoded);
+  ASSERT_OK(DecodeBlogProperties(&input, &decoded));
+  ASSERT_EQ(decoded.size(), 3u);
+  ASSERT_EQ(decoded[0].first, "CompressionCompatibilityName");
+  ASSERT_EQ(decoded[0].second, "zstd");
+  ASSERT_EQ(decoded[1].first, "role");
+  ASSERT_EQ(decoded[1].second, "wal");
+  ASSERT_EQ(decoded[2].first, "compressionSettings");
+  ASSERT_EQ(decoded[2].second, "level=3");
+}
+
+TEST_F(BlogFormatTest, DecodePropertiesTruncated) {
+  // Write a name but no value
+  std::string encoded;
+  PutLengthPrefixedSlice(&encoded, "key");
+  // Truncate before value
+  BlogPropertyMap decoded;
+  Slice input(encoded);
+  ASSERT_TRUE(DecodeBlogProperties(&input, &decoded).IsCorruption());
+}
+
+// --- IsBlogRequiredProperty ---
+
+TEST_F(BlogFormatTest, IsBlogRequiredProperty) {
+  ASSERT_TRUE(IsBlogRequiredProperty("CompressionCompatibilityName"));
+  ASSERT_TRUE(IsBlogRequiredProperty("TimestampSize"));
+  ASSERT_TRUE(IsBlogRequiredProperty("A"));
+  ASSERT_FALSE(IsBlogRequiredProperty("role"));
+  ASSERT_FALSE(IsBlogRequiredProperty("compressionSettings"));
+  ASSERT_FALSE(IsBlogRequiredProperty("a"));
+  ASSERT_FALSE(IsBlogRequiredProperty(""));
+}
+
+// --- Escape sequence generation ---
+
+TEST_F(BlogFormatTest, GenerateRandomFieldsConstraints) {
+  // Generate many escape sequences and verify constraints
+  for (int i = 0; i < 100; ++i) {
+    BlogFileHeader header;
+    header.GenerateRandomFields();
+
+    // First byte must not be 0x00 or 0xFF
+    uint8_t first = static_cast<uint8_t>(header.escape_sequence[0]);
+    ASSERT_NE(first, 0x00u) << "iteration " << i;
+    ASSERT_NE(first, 0xFFu) << "iteration " << i;
+
+    // Derived bytes must match
+    ASSERT_TRUE(BlogFileHeader::VerifyEscapeSequence(header.escape_sequence))
+        << "iteration " << i;
+  }
+}
+
+TEST_F(BlogFormatTest, IncarnationIdNonzero) {
+  BlogFileHeader header;
+  header.GenerateRandomFields();
+  // incarnation_id is first 4 bytes little-endian; since byte[0] is not 0,
+  // the incarnation_id must be nonzero.
+  ASSERT_NE(header.incarnation_id(), 0u);
+}
+
+TEST_F(BlogFormatTest, VerifyEscapeSequenceRejectsInvalid) {
+  char seq[kBlogEscapeSequenceSize] = {};
+  // All zeros: first byte is 0x00 -> invalid
+  ASSERT_FALSE(BlogFileHeader::VerifyEscapeSequence(seq));
+
+  // Valid first byte but wrong derived part
+  seq[0] = 0x42;
+  seq[1] = 0x13;
+  // Derived part is random garbage, likely won't match
+  ASSERT_FALSE(BlogFileHeader::VerifyEscapeSequence(seq));
+}
+
+TEST_F(BlogFormatTest, HeuristicEscapeSequenceDetection) {
+  // Generate a valid escape sequence and verify we can detect it
+  // heuristically (by checking derived bytes against random part).
+  BlogFileHeader header;
+  header.GenerateRandomFields();
+
+  // VerifyEscapeSequence does exactly this heuristic check
+  ASSERT_TRUE(BlogFileHeader::VerifyEscapeSequence(header.escape_sequence));
+
+  // Corrupt one random byte -> should fail verification
+  char corrupted[kBlogEscapeSequenceSize];
+  memcpy(corrupted, header.escape_sequence, kBlogEscapeSequenceSize);
+  corrupted[2] ^= 0x42;
+  // Might still pass if the corruption happens to produce a valid derived
+  // part, but astronomically unlikely
+  // (We don't ASSERT_FALSE here because of the tiny probability)
+}
+
+// --- BlogFileHeader encode/decode ---
+
+TEST_F(BlogFormatTest, HeaderEncodeDecodeMinimal) {
+  BlogFileHeader header;
+  header.checksum_type = kXXH3;
+  header.compact_record_type = kBlogWriteBatchRecord;
+  header.GenerateRandomFields();
+
+  std::string encoded;
+  header.EncodeTo(&encoded);
+  ASSERT_GE(encoded.size(), kBlogFileFixedHeaderSize);
+
+  BlogFileHeader decoded;
+  Slice input(encoded);
+  ASSERT_OK(decoded.DecodeFrom(&input));
+
+  ASSERT_EQ(decoded.schema_version, header.schema_version);
+  ASSERT_EQ(decoded.checksum_type, header.checksum_type);
+  ASSERT_EQ(decoded.compact_record_type, header.compact_record_type);
+  ASSERT_EQ(memcmp(decoded.escape_sequence, header.escape_sequence,
+                   kBlogEscapeSequenceSize),
+            0);
+  ASSERT_TRUE(decoded.properties.empty());
+  ASSERT_EQ(input.size(), 0u);  // all bytes consumed
+}
+
+TEST_F(BlogFormatTest, HeaderEncodeDecodeWithProperties) {
+  BlogFileHeader header;
+  header.checksum_type = kCRC32c;
+  header.compact_record_type = kBlogBlobRecord;
+  header.GenerateRandomFields();
+  header.SetProperty("CompressionCompatibilityName", "lz4");
+  header.SetProperty("role", "blob");
+  header.SetProperty("compressionSettings", "level=1");
+
+  std::string encoded;
+  header.EncodeTo(&encoded);
+
+  BlogFileHeader decoded;
+  Slice input(encoded);
+  ASSERT_OK(decoded.DecodeFrom(&input));
+
+  ASSERT_EQ(decoded.GetProperty("CompressionCompatibilityName"), "lz4");
+  ASSERT_EQ(decoded.GetProperty("role"), "blob");
+  ASSERT_EQ(decoded.GetProperty("compressionSettings"), "level=1");
+  ASSERT_EQ(input.size(), 0u);
+}
+
+TEST_F(BlogFormatTest, HeaderRejectsUnknownRequiredProperty) {
+  BlogFileHeader header;
+  header.GenerateRandomFields();
+  header.SetProperty("FutureRequired", "something");
+
+  std::string encoded;
+  header.EncodeTo(&encoded);
+
+  BlogFileHeader decoded;
+  Slice input(encoded);
+  Status s = decoded.DecodeFrom(&input);
+  ASSERT_TRUE(s.IsNotSupported()) << s.ToString();
+}
+
+TEST_F(BlogFormatTest, HeaderRejectsNewerSchemaVersion) {
+  BlogFileHeader header;
+  header.GenerateRandomFields();
+
+  std::string encoded;
+  header.EncodeTo(&encoded);
+
+  // Tamper with schema version byte (offset 12) to a future version.
+  // Must also recompute the fixed header checksum (bytes [36-39]) with
+  // context modifier using the incarnation_id.
+  encoded[12] = static_cast<char>(kBlogCurrentSchemaVersion + 1);
+  uint32_t new_checksum =
+      ComputeBuiltinChecksum(header.checksum_type, encoded.data(), 36) +
+      ChecksumModifierForContext(header.incarnation_id(), 0);
+  EncodeFixed32(&encoded[36], new_checksum);
+
+  BlogFileHeader decoded;
+  Slice input(encoded);
+  Status s = decoded.DecodeFrom(&input);
+  ASSERT_TRUE(s.IsNotSupported()) << s.ToString();
+  ASSERT_NE(s.ToString().find("newer than supported"), std::string::npos)
+      << s.ToString();
+}
+
+TEST_F(BlogFormatTest, HeaderCurrentSchemaVersionAccepted) {
+  BlogFileHeader header;
+  header.GenerateRandomFields();
+  ASSERT_EQ(header.schema_version, kBlogCurrentSchemaVersion);
+
+  std::string encoded;
+  header.EncodeTo(&encoded);
+
+  BlogFileHeader decoded;
+  Slice input(encoded);
+  ASSERT_OK(decoded.DecodeFrom(&input));
+  ASSERT_EQ(decoded.schema_version, kBlogCurrentSchemaVersion);
+}
+
+TEST_F(BlogFormatTest, TypedPropertyRoundTrip) {
+  BlogFileHeader header;
+  header.GenerateRandomFields();
+  header.SetUint64Property("fileNumber", 12345678ULL);
+  header.SetUint32Property("columnFamilyId", 42);
+
+  std::string encoded;
+  header.EncodeTo(&encoded);
+
+  BlogFileHeader decoded;
+  Slice input(encoded);
+  ASSERT_OK(decoded.DecodeFrom(&input));
+
+  uint64_t fn = 0;
+  ASSERT_TRUE(decoded.GetUint64Property("fileNumber", &fn));
+  ASSERT_EQ(fn, 12345678ULL);
+
+  uint32_t cf_id = 0;
+  ASSERT_TRUE(decoded.GetUint32Property("columnFamilyId", &cf_id));
+  ASSERT_EQ(cf_id, 42u);
+
+  // Missing property returns false
+  uint64_t missing = 0;
+  ASSERT_FALSE(decoded.GetUint64Property("nonexistent", &missing));
+}
+
+TEST_F(BlogFormatTest, HeaderAcceptsUnknownIgnorableProperty) {
+  BlogFileHeader header;
+  header.GenerateRandomFields();
+  header.SetProperty("futureIgnorable", "something");
+
+  std::string encoded;
+  header.EncodeTo(&encoded);
+
+  BlogFileHeader decoded;
+  Slice input(encoded);
+  ASSERT_OK(decoded.DecodeFrom(&input));
+  ASSERT_EQ(decoded.GetProperty("futureIgnorable"), "something");
+}
+
+TEST_F(BlogFormatTest, HeaderChecksumCorruption) {
+  BlogFileHeader header;
+  header.GenerateRandomFields();
+
+  std::string encoded;
+  header.EncodeTo(&encoded);
+
+  // Corrupt a byte in the fixed header
+  encoded[14] ^= 0xFF;
+
+  BlogFileHeader decoded;
+  Slice input(encoded);
+  ASSERT_TRUE(decoded.DecodeFrom(&input).IsCorruption());
+}
+
+TEST_F(BlogFormatTest, HeaderPropertyChecksumCorruption) {
+  BlogFileHeader header;
+  header.GenerateRandomFields();
+  header.SetProperty("role", "wal");
+
+  std::string encoded;
+  header.EncodeTo(&encoded);
+
+  // Corrupt a byte in the property section (after fixed header)
+  if (encoded.size() > kBlogFileFixedHeaderSize + 2) {
+    encoded[kBlogFileFixedHeaderSize + 2] ^= 0xFF;
+  }
+
+  BlogFileHeader decoded;
+  Slice input(encoded);
+  Status s = decoded.DecodeFrom(&input);
+  ASSERT_TRUE(s.IsCorruption()) << s.ToString();
+}
+
+TEST_F(BlogFormatTest, HeaderSetPropertyOverwrites) {
+  BlogFileHeader header;
+  header.SetProperty("role", "wal");
+  ASSERT_EQ(header.GetProperty("role"), "wal");
+
+  header.SetProperty("role", "blob");
+  ASSERT_EQ(header.GetProperty("role"), "blob");
+  // Should not have duplicate entries
+  int count = 0;
+  for (const auto& [k, v] : header.properties) {
+    if (k == "role") {
+      ++count;
+    }
+  }
+  ASSERT_EQ(count, 1);
+}
+
+TEST_F(BlogFormatTest, HeaderMagicValues) {
+  BlogFileHeader header;
+  header.GenerateRandomFields();
+
+  std::string encoded;
+  header.EncodeTo(&encoded);
+
+  // Verify magic bytes
+  ASSERT_GE(encoded.size(), kBlogFileMagicSize);
+  ASSERT_EQ(memcmp(encoded.data(), kBlogFileMagic, kBlogFileMagicSize), 0);
+}
+
+// --- Footer locator ---
+
+TEST_F(BlogFormatTest, FooterLocatorEncodeDecodeEmpty) {
+  BlogFileFooterLocator locator;
+
+  std::string encoded;
+  locator.EncodeTo(&encoded);
+  ASSERT_EQ(encoded.size(), 0u);
+
+  BlogFileFooterLocator decoded;
+  ASSERT_OK(decoded.DecodeFrom(Slice(encoded)));
+  ASSERT_TRUE(decoded.entries.empty());
+}
+
+TEST_F(BlogFormatTest, FooterLocatorEncodeDecodeMultiple) {
+  BlogFileFooterLocator locator;
+  locator.entries.push_back({kBlogFooterPropertiesRecord, 50});
+  locator.entries.push_back({kBlogFooterIndexRecord, 85});
+
+  std::string encoded;
+  locator.EncodeTo(&encoded);
+  ASSERT_EQ(encoded.size(), 10u);  // 2 * (1 + 4)
+
+  BlogFileFooterLocator decoded;
+  ASSERT_OK(decoded.DecodeFrom(Slice(encoded)));
+  ASSERT_EQ(decoded.entries.size(), 2u);
+  ASSERT_EQ(decoded.entries[0].record_type, kBlogFooterPropertiesRecord);
+  ASSERT_EQ(decoded.entries[0].relative_offset_4B, 50u);
+  ASSERT_EQ(decoded.entries[1].record_type, kBlogFooterIndexRecord);
+  ASSERT_EQ(decoded.entries[1].relative_offset_4B, 85u);
+}
+
+// --- Footer properties ---
+
+TEST_F(BlogFormatTest, FooterPropertiesEncodeDecodeRoundTrip) {
+  BlogFileFooterProperties props;
+  props.SetBlobCount(42);
+  props.SetTotalBlobBytes(123456);
+  props.SetSequenceRange(100, 200);
+
+  std::string encoded;
+  props.EncodeTo(&encoded);
+
+  BlogFileFooterProperties decoded;
+  ASSERT_OK(decoded.DecodeFrom(Slice(encoded)));
+  ASSERT_EQ(decoded.properties.size(), 4u);
+}
+
+// --- Padding ---
+
+TEST_F(BlogFormatTest, PaddingLastByteZero) {
+  // When last byte is 0x00, must pad with 0xFF, at least 1 byte
+  std::string pad;
+  // At offset 0 (already aligned), still need at least 1 byte
+  ComputeBlogPadding(0x00, 0, &pad);
+  ASSERT_GE(pad.size(), 1u);
+  for (char c : pad) {
+    ASSERT_EQ(static_cast<uint8_t>(c), 0xFFu);
+  }
+  // Result must be 4-byte aligned
+  ASSERT_EQ(pad.size() % 4, 0u);
+}
+
+TEST_F(BlogFormatTest, PaddingLastByteFF) {
+  // When last byte is 0xFF, must pad with 0x00, at least 1 byte
+  std::string pad;
+  ComputeBlogPadding(0xFF, 0, &pad);
+  ASSERT_GE(pad.size(), 1u);
+  for (char c : pad) {
+    ASSERT_EQ(static_cast<uint8_t>(c), 0x00u);
+  }
+  ASSERT_EQ(pad.size() % 4, 0u);
+}
+
+TEST_F(BlogFormatTest, PaddingLastByteOther) {
+  // When last byte is something else, pad only if needed for alignment
+  std::string pad;
+  ComputeBlogPadding(0x42, 0, &pad);
+  // Already aligned, no padding needed
+  ASSERT_EQ(pad.size(), 0u);
+
+  pad.clear();
+  ComputeBlogPadding(0x42, 1, &pad);
+  // Need 3 bytes to reach alignment
+  ASSERT_EQ(pad.size(), 3u);
+  for (char c : pad) {
+    ASSERT_EQ(static_cast<uint8_t>(c), 0x00u);
+  }
+}
+
+TEST_F(BlogFormatTest, PaddingAlignment) {
+  for (size_t offset = 0; offset < 8; ++offset) {
+    std::string pad;
+    ComputeBlogPadding(0x42, offset, &pad);
+    size_t after = offset + pad.size();
+    ASSERT_EQ(after % 4, 0u) << "offset=" << offset;
+  }
+}
+
+// --- Irregular varint ---
+
+TEST_F(BlogFormatTest, IrregularVarintZero) {
+  std::string encoded;
+  PutBlogIrregularVarint64(&encoded, 0, 4);
+  ASSERT_GE(encoded.size(), 4u);
+
+  // Must decode back to 0
+  Slice input(encoded);
+  uint64_t value;
+  ASSERT_TRUE(GetVarint64(&input, &value));
+  ASSERT_EQ(value, 0u);
+}
+
+TEST_F(BlogFormatTest, IrregularVarintSmallValue) {
+  std::string encoded;
+  PutBlogIrregularVarint64(&encoded, 42, 4);
+  ASSERT_GE(encoded.size(), 4u);
+
+  Slice input(encoded);
+  uint64_t value;
+  ASSERT_TRUE(GetVarint64(&input, &value));
+  ASSERT_EQ(value, 42u);
+}
+
+TEST_F(BlogFormatTest, IrregularVarintLargeValue) {
+  // A value that naturally needs 3 bytes, padded to 5
+  uint64_t original = 100000;
+  std::string encoded;
+  PutBlogIrregularVarint64(&encoded, original, 5);
+  ASSERT_GE(encoded.size(), 5u);
+
+  Slice input(encoded);
+  uint64_t value;
+  ASSERT_TRUE(GetVarint64(&input, &value));
+  ASSERT_EQ(value, original);
+}
+
+TEST_F(BlogFormatTest, IrregularVarintNaturallyLargeEnough) {
+  // A value that naturally needs 5+ bytes should not be padded further
+  uint64_t original = 1ULL << 35;
+  std::string encoded;
+  PutBlogIrregularVarint64(&encoded, original, 4);
+  // Natural encoding is 6 bytes, already >= 4
+  ASSERT_EQ(encoded.size(), 6u);
+
+  Slice input(encoded);
+  uint64_t value;
+  ASSERT_TRUE(GetVarint64(&input, &value));
+  ASSERT_EQ(value, original);
+}
+
+TEST_F(BlogFormatTest, UnspecifiedSizeVarint) {
+  std::string encoded;
+  PutVarint64(&encoded, kBlogUnspecifiedSize);
+  // 2^63 - 1 should encode to 9 bytes (63 bits / 7 = 9)
+  ASSERT_EQ(encoded.size(), 9u);
+
+  Slice input(encoded);
+  uint64_t value;
+  ASSERT_TRUE(GetVarint64(&input, &value));
+  ASSERT_EQ(value, kBlogUnspecifiedSize);
+}
+
+// --- Checksum ---
+
+TEST_F(BlogFormatTest, ComputeBlogRecordChecksumBasic) {
+  const char* data = "hello world";
+  size_t size = strlen(data);
+
+  // With no context (incarnation_id = 0), should match standard checksum
+  uint32_t cksum = ComputeBlogRecordChecksum(
+      kXXH3, data, size, static_cast<char>(kNoCompression), 0, 0);
+  uint32_t expected = ComputeBuiltinChecksumWithLastByte(
+      kXXH3, data, size, static_cast<char>(kNoCompression));
+  ASSERT_EQ(cksum, expected);
+}
+
+TEST_F(BlogFormatTest, ComputeBlogRecordChecksumWithContext) {
+  const char* data = "hello world";
+  size_t size = strlen(data);
+
+  uint32_t cksum1 = ComputeBlogRecordChecksum(
+      kXXH3, data, size, static_cast<char>(kNoCompression), 0x12345678, 100);
+  uint32_t cksum2 = ComputeBlogRecordChecksum(
+      kXXH3, data, size, static_cast<char>(kNoCompression), 0x12345678, 200);
+
+  // Different offsets should produce different checksums
+  ASSERT_NE(cksum1, cksum2);
+
+  // Different incarnation IDs should produce different checksums
+  uint32_t cksum3 = ComputeBlogRecordChecksum(
+      kXXH3, data, size, static_cast<char>(kNoCompression), 0xABCDEF01, 100);
+  ASSERT_NE(cksum1, cksum3);
+}
+
+}  // namespace ROCKSDB_NAMESPACE
+
+int main(int argc, char** argv) {
+  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
@@ -0,0 +1,388 @@
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+
+#include "db/blog/blog_reader.h"
+
+#include <cassert>
+#include <cstring>
+
+#include "table/format.h"
+#include "util/coding.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+BlogFileReader::BlogFileReader(std::unique_ptr<SequentialFileReader>&& file,
+                               Reporter* reporter, bool verify_checksums)
+    : seq_file_(std::move(file)),
+      reporter_(reporter),
+      verify_checksums_(verify_checksums) {}
+
+Status BlogFileReader::ReadHeader(BlogFileHeader* header) {
+  assert(!header_read_);
+
+  // Read the fixed header to get property_section_size
+  std::string fixed_buf;
+  Slice fixed_slice;
+  Status s = ReadBytes(kBlogFileFixedHeaderSize, &fixed_slice, &fixed_buf);
+  if (!s.ok()) {
+    return s;
+  }
+
+  // Peek at property_section_size from bytes [32-35]
+  uint32_t prop_section_size = DecodeFixed32(fixed_slice.data() + 32);
+
+  // Read the property section
+  std::string prop_buf;
+  Slice prop_slice;
+  s = ReadBytes(prop_section_size, &prop_slice, &prop_buf);
+  if (!s.ok()) {
+    return s;
+  }
+
+  // Combine into a single buffer for decoding
+  std::string full_header;
+  full_header.append(fixed_slice.data(), fixed_slice.size());
+  full_header.append(prop_slice.data(), prop_slice.size());
+
+  Slice input(full_header);
+  s = header->DecodeFrom(&input);
+  if (!s.ok()) {
+    return s;
+  }
+
+  header_ = *header;
+  header_read_ = true;
+
+  // Skip padding after header to reach the first record's escape sequence.
+  // Padding may be arbitrarily long (for stronger alignment or recycled
+  // files of all zeros). EOF here is fine (header-only file, no records).
+  s = SkipPadding();
+  if (!s.ok() && !s.IsNotFound()) {
+    return s;
+  }
+  return Status::OK();
+}
+
+Status BlogFileReader::ReadRecord(BlogRecordType* type, Slice* payload,
+                                  std::string* scratch, uint64_t* record_offset,
+                                  CompressionType* record_compression_type) {
+  if (!header_read_) {
+    return Status::Corruption("Blog reader: header not read");
+  }
+  if (eof_) {
+    return Status::NotFound();
+  }
+
+  Status s;
+  scratch->clear();
+
+  // Read escape sequence. If we have a pending prefix from header padding
+  // skip or inter-record padding skip, use it as the first 4 bytes.
+  std::string esc_buf;
+  if (!pending_escape_prefix_.empty()) {
+    esc_buf = std::move(pending_escape_prefix_);
+    pending_escape_prefix_.clear();
+    Slice rest_slice;
+    std::string rest_buf;
+    s = ReadBytes(kBlogEscapeSequenceSize - 4, &rest_slice, &rest_buf);
+    if (!s.ok()) {
+      eof_ = true;
+      // Short read after we had a pending prefix = incomplete trailing record
+      return Status::Incomplete("Blog reader: incomplete escape sequence");
+    }
+    esc_buf.append(rest_slice.data(), rest_slice.size());
+  } else {
+    Slice esc_slice;
+    s = ReadBytes(kBlogEscapeSequenceSize, &esc_slice, &esc_buf);
+    if (!s.ok()) {
+      eof_ = true;
+      return Status::NotFound();  // clean EOF
+    }
+    if (esc_slice.data() != esc_buf.data()) {
+      esc_buf.assign(esc_slice.data(), esc_slice.size());
+    }
+  }
+
+  // Verify escape sequence matches
+  if (memcmp(esc_buf.data(), header_.escape_sequence,
+             kBlogEscapeSequenceSize) != 0) {
+    return ReportCorruption(kBlogEscapeSequenceSize,
+                            "escape sequence mismatch");
+  }
+
+  uint64_t rec_offset = offset_ - kBlogEscapeSequenceSize;
+  if (record_offset) {
+    *record_offset = rec_offset;
+  }
+  last_record_offset_ = rec_offset;
+
+  // Read varint length. scratch receives the raw varint bytes for use
+  // in prefix checksum verification (avoids fragile re-encoding).
+  uint64_t length = 0;
+  s = ReadVarint64(&length, scratch);
+  if (!s.ok()) {
+    eof_ = true;
+    return Status::Incomplete("Blog reader: incomplete varint");
+  }
+  size_t varint_len = scratch->size();
+
+  bool is_full_format = (varint_len > kBlogCompactVarintMaxBytes);
+
+  BlogRecordType rec_type;
+  std::string prefix_rest_buf;
+
+  if (is_full_format) {
+    // Full format: read type + compression_type + prefix_checksum
+    Slice prefix_rest_slice;
+    s = ReadBytes(6, &prefix_rest_slice, &prefix_rest_buf);  // 1+1+4
+    if (!s.ok()) {
+      eof_ = true;
+      return Status::Incomplete("Blog reader: incomplete full record prefix");
+    }
+
+    rec_type =
+        static_cast<BlogRecordType>(static_cast<uint8_t>(prefix_rest_slice[0]));
+
+    if (verify_checksums_) {
+      // Build the prefix data from the original varint bytes (in scratch)
+      // plus type and compression_type bytes.
+      scratch->push_back(prefix_rest_slice[0]);  // type
+      scratch->push_back(prefix_rest_slice[1]);  // comp_type
+
+      uint32_t stored_prefix_checksum =
+          DecodeFixed32(prefix_rest_slice.data() + 2);
+      uint32_t computed_prefix_checksum =
+          ComputeBuiltinChecksum(header_.checksum_type, scratch->data(),
+                                 scratch->size()) +
+          ChecksumModifierForContext(header_.incarnation_id(), rec_offset);
+      if (stored_prefix_checksum != computed_prefix_checksum) {
+        return ReportCorruption(varint_len + 6, "prefix checksum mismatch");
+      }
+    }
+  } else {
+    rec_type = header_.compact_record_type;
+  }
+
+  *type = rec_type;
+
+  if (length == 0) {
+    payload->clear();
+    if (record_compression_type) {
+      *record_compression_type = kNoCompression;
+    }
+    s = SkipPadding();
+    if (!s.ok() && !s.IsNotFound()) {
+      return s;
+    }
+    return Status::OK();
+  }
+
+  if (length == kBlogUnspecifiedSize) {
+    return ReportCorruption(0, "unspecified-size records not yet implemented");
+  }
+
+  // Read payload
+  scratch->clear();
+  Slice payload_slice;
+  s = ReadBytes(static_cast<size_t>(length), &payload_slice, scratch);
+  if (!s.ok()) {
+    eof_ = true;
+    return Status::Incomplete("Blog reader: incomplete payload");
+  }
+  if (payload_slice.data() != scratch->data()) {
+    scratch->assign(payload_slice.data(), payload_slice.size());
+  }
+
+  // Read 5-byte trailer
+  Slice trailer_slice;
+  std::string trailer_buf;
+  s = ReadBytes(kBlogBlockTrailerSize, &trailer_slice, &trailer_buf);
+  if (!s.ok()) {
+    eof_ = true;
+    return Status::Incomplete("Blog reader: incomplete trailer");
+  }
+
+  char trailer_comp_type = trailer_slice[0];
+  uint32_t stored_checksum = DecodeFixed32(trailer_slice.data() + 1);
+
+  if (verify_checksums_) {
+    uint32_t computed_checksum = ComputeBlogRecordChecksum(
+        header_.checksum_type, scratch->data(), scratch->size(),
+        trailer_comp_type, header_.incarnation_id(),
+        offset_ - kBlogBlockTrailerSize - length);
+    if (stored_checksum != computed_checksum) {
+      return ReportCorruption(
+          static_cast<size_t>(length) + kBlogBlockTrailerSize,
+          "record checksum mismatch");
+    }
+  }
+
+  *payload = Slice(*scratch);
+  if (record_compression_type) {
+    *record_compression_type =
+        static_cast<CompressionType>(static_cast<uint8_t>(trailer_comp_type));
+  }
+
+  // Skip padding to next record.
+  s = SkipPadding();
+  if (!s.ok() && !s.IsNotFound()) {
+    return s;
+  }
+
+  return Status::OK();
+}
+
+Status BlogFileReader::ScanForEscapeSequence(uint64_t* found_offset) {
+  // Scan forward 4 bytes at a time (escape sequences are 32-bit aligned).
+  // Check first 4 bytes of escape sequence, then verify remaining 6 bytes.
+  uint32_t first4;
+  memcpy(&first4, header_.escape_sequence, 4);
+
+  std::string buf;
+  // Align to 4-byte boundary first
+  size_t remainder = offset_ % 4;
+  if (remainder != 0) {
+    size_t skip = 4 - remainder;
+    Slice skip_slice;
+    Status s = ReadBytes(skip, &skip_slice, &buf);
+    if (!s.ok()) {
+      return s;
+    }
+  }
+
+  while (!eof_) {
+    Slice chunk_slice;
+    Status s = ReadBytes(4, &chunk_slice, &buf);
+    if (!s.ok()) {
+      if (eof_) {
+        return Status::NotFound("escape sequence not found before EOF");
+      }
+      return s;
+    }
+
+    uint32_t candidate;
+    memcpy(&candidate, chunk_slice.data(), 4);
+    if (candidate == first4) {
+      // Potential match - verify remaining 6 bytes
+      uint64_t candidate_offset = offset_ - 4;
+      Slice rest_slice;
+      std::string rest_buf;
+      s = ReadBytes(kBlogEscapeSequenceSize - 4, &rest_slice, &rest_buf);
+      if (!s.ok()) {
+        return s;
+      }
+
+      if (memcmp(rest_slice.data(), header_.escape_sequence + 4,
+                 kBlogEscapeSequenceSize - 4) == 0) {
+        *found_offset = candidate_offset;
+        return Status::OK();
+      }
+      // False match, continue scanning. But we consumed 6 extra bytes that
+      // might not be aligned. Re-align.
+      remainder = offset_ % 4;
+      if (remainder != 0) {
+        size_t skip = 4 - remainder;
+        Slice skip_s;
+        s = ReadBytes(skip, &skip_s, &buf);
+        if (!s.ok()) {
+          return s;
+        }
+      }
+    }
+  }
+  return Status::NotFound("escape sequence not found before EOF");
+}
+
+Status BlogFileReader::SkipPadding() {
+  // Skip arbitrarily long padding (0x00 or 0xFF bytes). Padding is
+  // 32-bit aligned. Since the escape sequence's first byte is guaranteed
+  // to be neither 0x00 nor 0xFF, we align to 4 bytes then scan 4-byte
+  // chunks until we find one that starts with a non-padding byte.
+  size_t remainder = offset_ % 4;
+  if (remainder != 0) {
+    Slice skip_slice;
+    std::string skip_buf;
+    Status s = ReadBytes(4 - remainder, &skip_slice, &skip_buf);
+    if (!s.ok()) {
+      if (eof_) {
+        return Status::NotFound();
+      }
+      return s;
+    }
+  }
+  while (true) {
+    Slice chunk_slice;
+    std::string chunk_buf;
+    Status s = ReadBytes(4, &chunk_slice, &chunk_buf);
+    if (!s.ok()) {
+      if (eof_) {
+        return Status::NotFound();
+      }
+      return s;
+    }
+    uint8_t first = static_cast<uint8_t>(chunk_slice[0]);
+    if (first != 0x00 && first != 0xFF) {
+      // Found the start of the next escape sequence.
+      pending_escape_prefix_.assign(chunk_slice.data(), 4);
+      return Status::OK();
+    }
+  }
+}
+
+Status BlogFileReader::ReadBytes(size_t n, Slice* result,
+                                 std::string* scratch) {
+  scratch->resize(n);
+  Slice read_result;
+  IOStatus ios =
+      seq_file_->Read(n, &read_result, scratch->data(), Env::IO_TOTAL);
+  if (!ios.ok()) {
+    return static_cast<Status>(ios);
+  }
+  if (read_result.size() < n) {
+    eof_ = true;
+    // Return Incomplete -- the caller (ReadRecord) determines whether
+    // this is an acceptable incomplete tail vs. genuine corruption.
+    return Status::Incomplete("Blog reader", "unexpected EOF");
+  }
+  offset_ += n;
+  *result = Slice(scratch->data(), n);
+  return Status::OK();
+}
+
+// FIXME? Consider a better encoding that could be processed more efficiently
+Status BlogFileReader::ReadVarint64(uint64_t* value, std::string* scratch) {
+  // Varints can be up to 10 bytes. Read one byte at a time.
+  // The raw varint bytes are appended to scratch so the caller can use
+  // them for checksum verification without re-encoding.
+  scratch->clear();
+  std::string byte_buf;
+  for (int i = 0; i < 10; ++i) {
+    Slice byte_slice;
+    Status s = ReadBytes(1, &byte_slice, &byte_buf);
+    if (!s.ok()) {
+      return s;
+    }
+    scratch->push_back(byte_slice[0]);
+    // Check if this is the terminal byte (high bit not set)
+    if ((static_cast<uint8_t>(byte_slice[0]) & 0x80) == 0) {
+      Slice varint_slice(*scratch);
+      if (!GetVarint64(&varint_slice, value)) {
+        return ReportCorruption(scratch->size(), "invalid varint");
+      }
+      return Status::OK();
+    }
+  }
+  return ReportCorruption(10, "varint too long");
+}
+
+Status BlogFileReader::ReportCorruption(size_t bytes, const std::string& msg) {
+  Status s = Status::Corruption("Blog reader", msg);
+  if (reporter_) {
+    reporter_->Corruption(bytes, s);
+  }
+  return s;
+}
+
+}  // namespace ROCKSDB_NAMESPACE
@@ -0,0 +1,101 @@
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <string>
+
+#include "db/blog/blog_format.h"
+#include "file/random_access_file_reader.h"
+#include "file/sequence_file_reader.h"
+#include "rocksdb/slice.h"
+#include "rocksdb/status.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+// Reads blog-format files sequentially (WAL replay) or at random offsets
+// (blob lookups). Supports footer reading by backward scanning.
+class BlogFileReader {
+ public:
+  // Error reporter, same pattern as log::Reader::Reporter.
+  class Reporter {
+   public:
+    virtual ~Reporter() = default;
+    virtual void Corruption(size_t bytes, const Status& status) = 0;
+  };
+
+  // Construct for sequential reading (WAL replay, forward scan).
+  BlogFileReader(std::unique_ptr<SequentialFileReader>&& file,
+                 Reporter* reporter, bool verify_checksums);
+
+  ~BlogFileReader() = default;
+
+  // Take ownership of a reporter (e.g., an adapter wrapping another type).
+  void SetOwnedReporter(std::unique_ptr<Reporter> reporter) {
+    owned_reporter_ = std::move(reporter);
+    reporter_ = owned_reporter_.get();
+  }
+
+  // Read and validate the file header. Must be called first.
+  Status ReadHeader(BlogFileHeader* header);
+
+  // Read the next record sequentially. Returns:
+  //   OK - record read successfully
+  //   NotFound - clean EOF (no more records, only padding/zeros remain)
+  //   Incomplete - partial record at tail (crash mid-write)
+  //   Corruption - data integrity error
+  // On OK, *type is the record type and *payload contains the payload.
+  // *scratch is used as backing storage for payload.
+  Status ReadRecord(BlogRecordType* type, Slice* payload, std::string* scratch,
+                    uint64_t* record_offset = nullptr,
+                    CompressionType* record_compression_type = nullptr);
+
+  // Scan forward from the current position for the next occurrence of
+  // the file's escape sequence. Used for WAL recovery and unspecified-
+  // size record parsing.
+  // On success, *found_offset is the file offset of the escape sequence.
+  Status ScanForEscapeSequence(uint64_t* found_offset);
+
+  bool IsEOF() const { return eof_; }
+  uint64_t LastRecordOffset() const { return last_record_offset_; }
+  uint64_t current_offset() const { return offset_; }
+  const BlogFileHeader& header() const { return header_; }
+
+ private:
+  // Skip arbitrarily long padding (0x00 or 0xFF bytes) after a record or
+  // header. Aligns to 4-byte boundary first, then scans 4-byte chunks
+  // until finding one whose first byte is not 0x00/0xFF. Stashes that
+  // chunk in pending_escape_prefix_ for the next ReadRecord call.
+  // Returns OK on success, NotFound on clean EOF (no more records),
+  // or an error Status on I/O failure.
+  Status SkipPadding();
+
+  // Read exactly n bytes sequentially. Returns Corruption on short read.
+  Status ReadBytes(size_t n, Slice* result, std::string* scratch);
+
+  // Read a varint64 from the sequential stream.
+  Status ReadVarint64(uint64_t* value, std::string* scratch);
+
+  // Report corruption and return a Corruption status.
+  Status ReportCorruption(size_t bytes, const std::string& msg);
+
+  std::unique_ptr<SequentialFileReader> seq_file_;
+  Reporter* reporter_;
+  std::unique_ptr<Reporter> owned_reporter_;  // optional, for adapter lifetime
+  bool verify_checksums_;
+  BlogFileHeader header_;
+  bool header_read_ = false;
+  bool eof_ = false;
+  uint64_t offset_ = 0;
+  uint64_t last_record_offset_ = 0;
+
+  // First 4 bytes of escape sequence consumed during header padding skip.
+  // ReadRecord uses these as the beginning of the first escape sequence.
+  std::string pending_escape_prefix_;
+};
+
+}  // namespace ROCKSDB_NAMESPACE
Author	SHA1	Message	Date
Peter Dillinger	c8600f85f6	[ci] Add OPENAI_API_KEY check to Codex steps Add early exit checks to Codex steps so they skip gracefully when OPENAI_API_KEY is not configured, instead of failing with exit code 1. This prevents noise from Codex workflows when the API key is not set up.	2026-05-01 15:22:17 -07:00
Peter Dillinger	1f910525a7	[ci] Fix invalid secrets reference in workflow conditions The secrets context cannot be used directly in if conditions. Remove the invalid 'secrets.OPENAI_API_KEY != ''' checks that were added in the previous commit. This was causing workflow dispatch to fail with 'Looks like something went wrong!' error. The Codex workflows will now run but may fail if OPENAI_API_KEY is not configured. This is preferable to having an invalid workflow file.	2026-05-01 15:21:42 -07:00
Peter Dillinger	5239c4caeb	Merge remote-tracking branch 'pd/blog_format_no_wal' into fix_agent_review2	2026-05-01 14:10:57 -07:00
Peter Dillinger	2e21612c3e	Fix AI review workflows broken by `cc8d9ea04` Summary: This commit fixes several potential issues introduced by `cc8d9ea04` (CI: AI review workflow improvements) that broke the agent review jobs in GitHub CI. 1. Codex workflows failing due to missing OPENAI_API_KEY: - The commit added Codex review workflows, but they fail when OPENAI_API_KEY is not configured - Added 'secrets.OPENAI_API_KEY != ''' condition to all 13 Codex steps to skip gracefully when the API key is unavailable 2. Missing pull-requests: read permission in manual-review job: - The manual-review job calls github.rest.pulls.get() but lacked the required permission - Added 'pull-requests: read' to the manual-review job permissions 3. Potential crash when headSha is undefined: - parse-claude-review.js and parse-codex-review.js accessed meta.headSha.substring() without null check - Added defensive checks to handle undefined headSha gracefully 4. Claude model claude-opus-4-7 incompatible with thinking API: - The commit upgraded default model to claude-opus-4-7, but this model doesn't support the 'thinking.type.enabled' API used by the Claude Code action - Error: 'thinking.type.enabled' is not supported for this model. Use 'thinking.type.adaptive' and 'output_config.effort' to control thinking behavior - Reverted default model to claude-opus-4-6 and removed claude-opus-4-7 from options Test Plan: GitHub CI	2026-05-01 13:32:27 -07:00
Peter Dillinger	5ba6eb5497	Blog file format: unified WAL and blob file format (1/n) Summary: Introduces the "blog" file format (portmanteau of "blob" + "log"), a new unified file format for WAL and blob files in RocksDB. This change makes the new format an opt-in option for blob files ONLY. An immediate follow-up will add WAL support. This format is intended to be the future default for both WAL and blob files, and likely also manifest files. The impetus for this new file format was an apparent convergence in requirements for interesting and useful future directions for RocksDB, along with some tech debt: * Supporting blob "direct write" (key-value separation in the memtable) with WAL enabled and at least the option to have all the WAL+blob data go into one file to reduce overheads in some cases like WAL sync write with blob direct write. (In other cases, separating WAL WriteBatches and blobs into distinct files would likely be the better choice.) The "preamble start" marker record is intended to support this case so that WriteBatches can carry external values in a "preamble" in memory and the WriteBatch doesn't need to be rewritten on storage to a single blog file serving both WAL and blob functions. (Details in later work.) * Preserve the continuity of each blob value for efficient reads (NOTE: WAL/Manifest format often breaks up payloads), and extend this continuity to WriteBatches so that keys/values with known checksums could be carried and extended to the WriteBatch and its contiguous encoding in the blog-as-WAL file. (The goal is to leverage checksums across layers as much as possible rather than computing new ones at each layer; only CRC checksums are "extendable.") * Support some "linear log" workloads with monotonically increasing keys and FIFO pruning of old data. A CF could be configured to use its own blog-as-WAL files writing this data, and those files could get indexing information written to them as each file is sealed. This would enable moderately efficient read queries that process WriteBatch records for results, and no WAL->SST write amplification. * Modernize blog and WAL formats with features like explicit versioning and extensibility, configurable and context-aware checksums, debugging and statistical information, customizable compression (CompressionManager aware), and more. New DB options: use_blog_format_for_blobs, blog_checksum. Other public API changes: * ChecksumType moved to include/rocksdb/checksum_type.h. * kStreamingCompressionSentinel (0x7F) added to CompressionType enum. Some included refactoring: * BlobLogWriter::log_number_ removed (was unused). * BlobLogWriter::AppendFooter renamed to LegacyAppendFooterAndClose. Test Plan: TODO	2026-04-27 18:13:43 -07:00