diff --git a/.config/nextest.toml b/.config/nextest.toml
index 53b4cc20e5d..63a141f3773 100644
--- a/.config/nextest.toml
+++ b/.config/nextest.toml
@@ -1,3 +1,6 @@
+[profile.default]
+slow-timeout = { period = "30s", terminate-after = 5 }
+
 [[profile.default.overrides]]
-filter = 'test(compress_large_int)'
+filter = 'test(compress_large_int | fsst_compress_offsets_overflow_i32)'
 priority = 100
diff --git a/.github/workflows/bench-pr.yml b/.github/workflows/bench-pr.yml
index 1f8236bfb01..cfab4f7fd3b 100644
--- a/.github/workflows/bench-pr.yml
+++ b/.github/workflows/bench-pr.yml
@@ -38,7 +38,7 @@ jobs:
         if: github.event.pull_request.head.repo.fork == false
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
         with:
           ref: ${{ github.event.pull_request.head.sha }}
       - name: Setup benchmark environment
@@ -83,7 +83,7 @@ jobs:
 
       - name: Setup AWS CLI
         if: github.event.pull_request.head.repo.fork == false
-        uses: aws-actions/configure-aws-credentials@99214aa6889fcddfa57764031d71add364327e59  # v6
+        uses: aws-actions/configure-aws-credentials@e7f100cf4c008499ea8adda475de1042d6975c7b  # v6
         with:
           role-to-assume: arn:aws:iam::245040174862:role/GitHubBenchmarkRole
           aws-region: us-east-1
@@ -98,16 +98,8 @@ jobs:
         run: |
           set -Eeu -o pipefail -x
 
-          base_commit_sha=$(\
-            curl -L \
-              -H "Accept: application/vnd.github+json" \
-              -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" \
-              https://api.github.com/repos/vortex-data/vortex/actions/workflows/bench.yml/runs\?branch\=develop\&status\=success\&per_page\=1 \
-            | jq -r '.workflow_runs[].head_sha' \
-          )
-
           python3 scripts/s3-download.py s3://vortex-ci-benchmark-results/data.json.gz data.json.gz --no-sign-request
-          gzip -d -c data.json.gz | grep $base_commit_sha > base.json
+          gzip -d -c data.json.gz > base.json
 
           echo '# Benchmarks: ${{ matrix.benchmark.name }}' > comment.md
           echo '' >> comment.md
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 9a03c749669..839db948add 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -16,9 +16,9 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - name: Setup AWS CLI
-        uses: aws-actions/configure-aws-credentials@99214aa6889fcddfa57764031d71add364327e59  # v6
+        uses: aws-actions/configure-aws-credentials@e7f100cf4c008499ea8adda475de1042d6975c7b  # v6
         with:
           role-to-assume: arn:aws:iam::245040174862:role/GitHubBenchmarkRole
           aws-region: us-east-1
@@ -54,7 +54,7 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - name: Setup benchmark environment
         run: sudo bash scripts/setup-benchmark.sh
       - uses: ./.github/actions/setup-rust
@@ -95,7 +95,7 @@ jobs:
           bash scripts/bench-taskset.sh target/release_debug/${{ matrix.benchmark.id }} --formats ${{ matrix.benchmark.formats }} -d gh-json -o results.json --gh-json-v3 results.v3.jsonl
 
       - name: Setup AWS CLI
-        uses: aws-actions/configure-aws-credentials@99214aa6889fcddfa57764031d71add364327e59  # v6
+        uses: aws-actions/configure-aws-credentials@e7f100cf4c008499ea8adda475de1042d6975c7b  # v6
         with:
           role-to-assume: arn:aws:iam::245040174862:role/GitHubBenchmarkRole
           aws-region: us-east-1
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 58653ec0809..5798d1d56b0 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -29,14 +29,14 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: spiraldb/actions/.github/actions/lint-toml@a746510eafaa926484c354541cfc49b2ec06cc63  # 0.18.6
 
   validate-workflow-yaml:
     runs-on: ubuntu-latest
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - name: Validate YAML file
         run: |
           # Lint the workflows and yamllint's configuration file.
@@ -57,7 +57,7 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-prebuild
       - name: Install uv
         if: github.repository != 'vortex-data/vortex'
@@ -93,7 +93,7 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-prebuild
 
       - name: Pytest - Vortex
@@ -131,11 +131,16 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-prebuild
       - name: Docs
+        env:
+          # required to make sure docs build for features
+          RUSTDOCFLAGS: "-D warnings --cfg docsrs"
         run: |
-          RUSTDOCFLAGS="-D warnings" cargo doc --profile ci --no-deps
+          # Build docs for the whole workspace (aside from vortex-python that is having hard time with the python-docs syntax),
+          # including all private docs.
+          cargo doc --profile ci --no-deps --document-private-items --workspace --exclude vortex-python
           # nextest doesn't support doc tests, so we run it here
           cargo test --profile ci --doc --workspace --all-features --exclude vortex-cxx --exclude vortex-jni --exclude vortex-ffi --exclude xtask --no-fail-fast
 
@@ -174,7 +179,7 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-prebuild
       - name: Install wasm32 target
         if: ${{ matrix.config.target == 'wasm32-unknown-unknown' }}
@@ -199,7 +204,7 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-prebuild
       - run: cargo minimal-versions check --direct --workspace --ignore-private
 
@@ -215,7 +220,7 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-prebuild
       - name: Install nightly for fmt
         run: rustup toolchain install $NIGHTLY_TOOLCHAIN --component rustfmt
@@ -271,7 +276,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - name: C/C++ Lint - clang-format
         run: |
           git ls-files vortex-cuda vortex-cxx vortex-duckdb vortex-ffi \
@@ -293,7 +298,7 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-prebuild
       - name: Install cargo-hack
         if: github.repository != 'vortex-data/vortex'
@@ -325,7 +330,7 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - name: Setup (Windows)
         if: matrix.os == 'windows-x64'
         run: |
@@ -335,10 +340,11 @@ jobs:
         if: matrix.os == 'windows-x64'
         run: |
           cargo nextest run --cargo-profile ci --locked --workspace --all-features --no-fail-fast `
-            --exclude vortex-bench --exclude vortex-bench-server `
+            --exclude vortex-bench `
             --exclude vortex-python --exclude vortex-duckdb `
-            --exclude vortex-fuzz --exclude vortex-cuda --exclude vortex-nvcomp `
-            --exclude vortex-cub --exclude vortex-test-e2e-cuda --exclude duckdb-bench `
+            --exclude vortex-fuzz --exclude vortex-cuda --exclude vortex-cuda-ffi `
+            --exclude vortex-nvcomp --exclude vortex-cub --exclude vortex-test-e2e-cuda `
+            --exclude duckdb-bench `
             --exclude lance-bench --exclude datafusion-bench --exclude random-access-bench `
             --exclude compress-bench --exclude xtask --exclude vortex-datafusion `
             --exclude gpu-scan-cli --exclude vortex-sqllogictest
@@ -346,19 +352,6 @@ jobs:
         if: matrix.os != 'windows-x64'
         run: |
           cargo nextest run --cargo-profile ci --locked --workspace --all-features --no-fail-fast --exclude vortex-bench --exclude xtask --exclude vortex-sqllogictest
-      - name: vortex-bench-server admin snapshot tests (Linux only - network-dependent)
-        # The /api/admin/snapshot tests INSTALL+LOAD the vortex DuckDB
-        # core extension from extensions.duckdb.org on first call. They
-        # are #[ignore]'d by default so `cargo test` works in offline
-        # environments (sandboxed CI, local dev without network). This
-        # step runs them explicitly on the Linux runners, which DO have
-        # outbound network, so the entire backup contract is covered
-        # in CI before merge. macOS/arm64 also exercises them - same
-        # extension, same network. Windows skipped (bench-server is
-        # excluded from Windows test matrix above).
-        if: matrix.os == 'linux-x64' || matrix.os == 'linux-arm64' || matrix.os == 'macos-arm64'
-        run: |
-          cargo nextest run --cargo-profile ci --locked -p vortex-bench-server --test admin --run-ignored only
       - uses: ./.github/actions/check-rebuild
         if: matrix.os != 'windows-x64'
         with:
@@ -384,9 +377,11 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-prebuild
-      - run: ./gradlew test --parallel
+      - run: ./gradlew javadoc
+        working-directory: ./java
+      - run: ./gradlew check
         working-directory: ./java
 
   license-check-and-audit-check:
@@ -401,7 +396,7 @@ jobs:
     # Prevent sudden announcement of a new advisory from failing ci:
     continue-on-error: ${{ matrix.checks == 'advisories' }}
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: EmbarkStudios/cargo-deny-action@bb137d7af7e4fb67e5f82a49c4fce4fad40782fe  # v2
         with:
           command: check ${{ matrix.checks }}
@@ -418,7 +413,7 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-prebuild
       - name: Build and run C++ unit tests
         run: |
@@ -447,7 +442,7 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-prebuild
       - name: Run sqllogictest tests
         run: |
@@ -462,7 +457,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-rust
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
@@ -489,7 +484,7 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-prebuild
       - name: Install nightly for cbindgen macro expansion
         run: rustup toolchain install $NIGHTLY_TOOLCHAIN
@@ -528,7 +523,7 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-prebuild
       - name: "regenerate FFI header file"
         run: |
diff --git a/.github/workflows/claude-review.yml b/.github/workflows/claude-review.yml
index 24422c021c8..c95031a19e6 100644
--- a/.github/workflows/claude-review.yml
+++ b/.github/workflows/claude-review.yml
@@ -232,7 +232,7 @@ jobs:
       actions: read
     steps:
       - name: Checkout same-repo PR contents
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
         with:
           ref: ${{ needs.gate.outputs.checkout_ref }}
           fetch-depth: 1
@@ -242,7 +242,7 @@ jobs:
 
       - name: Run Claude Code in review-only mode
         id: claude
-        uses: anthropics/claude-code-action@787c5a0ce96a9a6cfb050ea0c8f4c05f2447c251  # v1.0.133
+        uses: anthropics/claude-code-action@fbda2eb1bdc90d319b8d853f5deb53bca199a7c1  # v1.0.140
         with:
           claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
           # This workflow deliberately uses the built-in token because it only needs
diff --git a/.github/workflows/claude-write.yml b/.github/workflows/claude-write.yml
index 45b488c9a56..5d6224fc18b 100644
--- a/.github/workflows/claude-write.yml
+++ b/.github/workflows/claude-write.yml
@@ -167,7 +167,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
         with:
           ref: ${{ needs.gate.outputs.checkout_ref }}
           fetch-depth: 0
@@ -197,7 +197,7 @@ jobs:
 
       - name: Run Claude Code
         id: claude
-        uses: anthropics/claude-code-action@787c5a0ce96a9a6cfb050ea0c8f4c05f2447c251  # v1.0.133
+        uses: anthropics/claude-code-action@fbda2eb1bdc90d319b8d853f5deb53bca199a7c1  # v1.0.140
         with:
           claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
           github_token: ${{ steps.app-token.outputs.token }}
diff --git a/.github/workflows/close-fixed-fuzzer-issues.yml b/.github/workflows/close-fixed-fuzzer-issues.yml
index bd365070e3c..9e7deda1f97 100644
--- a/.github/workflows/close-fixed-fuzzer-issues.yml
+++ b/.github/workflows/close-fixed-fuzzer-issues.yml
@@ -36,7 +36,7 @@ jobs:
         with:
           sccache: s3
 
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
 
       - uses: ./.github/actions/setup-rust
         with:
diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index 50a5cbaa75a..c819d5178d6 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -34,7 +34,7 @@ jobs:
           - { shard: 5, name: "Encodings 2", packages: "vortex-decimal-byte-parts vortex-fastlanes vortex-fsst", features: "--features _test-harness" }
           - { shard: 6, name: "Encodings 3", packages: "vortex-pco vortex-runend vortex-sequence" }
           - { shard: 7, name: "Encodings 4", packages: "vortex-sparse vortex-zigzag vortex-zstd" }
-          - { shard: 8, name: "Storage formats", packages: "vortex-flatbuffers vortex-proto vortex-btrblocks" }
+          - { shard: 8, name: "Storage formats & row encoding", packages: "vortex-flatbuffers vortex-proto vortex-btrblocks vortex-row" }
     name: "Benchmark with Codspeed (Shard #${{ matrix.shard }})"
     timeout-minutes: 30
     runs-on: >-
@@ -46,11 +46,14 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - name: Setup benchmark environment
         run: sudo bash scripts/setup-benchmark.sh
       - uses: ./.github/actions/setup-prebuild
       - uses: ./.github/actions/system-info
+      - run: |
+          sudo apt-get update
+          sudo apt-get install -y libc6-dbg
       - name: Install Codspeed
         uses: taiki-e/cache-cargo-install-action@66c9585ef5ca780ee69399975a5e911f47905995
         with:
@@ -82,7 +85,7 @@ jobs:
       - uses: runs-on/action@v2
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-rust
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
@@ -91,6 +94,9 @@ jobs:
           nvidia-smi
           nvidia-smi -L
           nvidia-smi -q -d Memory
+      - run: |
+          sudo apt-get update
+          sudo apt-get install -y libc6-dbg
       - name: Install Codspeed
         uses: taiki-e/cache-cargo-install-action@66c9585ef5ca780ee69399975a5e911f47905995
         with:
diff --git a/.github/workflows/compat-gen-upload.yml b/.github/workflows/compat-gen-upload.yml
index 63db97422c8..d3aafe0dfbb 100644
--- a/.github/workflows/compat-gen-upload.yml
+++ b/.github/workflows/compat-gen-upload.yml
@@ -38,13 +38,13 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
         with:
           fetch-depth: 0
       - uses: ./.github/actions/setup-prebuild
 
       - name: Configure AWS credentials
-        uses: aws-actions/configure-aws-credentials@99214aa6889fcddfa57764031d71add364327e59  # v6
+        uses: aws-actions/configure-aws-credentials@e7f100cf4c008499ea8adda475de1042d6975c7b  # v6
         with:
           role-to-assume: "arn:aws:iam::245040174862:role/GitHubCompatUploadRole"
           aws-region: us-east-1
@@ -88,13 +88,13 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
         with:
           fetch-depth: 0
       - uses: ./.github/actions/setup-prebuild
 
       - name: Configure AWS credentials
-        uses: aws-actions/configure-aws-credentials@99214aa6889fcddfa57764031d71add364327e59  # v6
+        uses: aws-actions/configure-aws-credentials@e7f100cf4c008499ea8adda475de1042d6975c7b  # v6
         with:
           role-to-assume: "arn:aws:iam::245040174862:role/GitHubCompatUploadRole"
           aws-region: us-east-1
diff --git a/.github/workflows/compat-validation.yml b/.github/workflows/compat-validation.yml
index 7be13aec5b3..e722d6f9f34 100644
--- a/.github/workflows/compat-validation.yml
+++ b/.github/workflows/compat-validation.yml
@@ -33,7 +33,7 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-prebuild
       - name: Run compat tests
         run: |
diff --git a/.github/workflows/cuda.yaml b/.github/workflows/cuda.yaml
index 6edb6ff5cb8..00faca7fd43 100644
--- a/.github/workflows/cuda.yaml
+++ b/.github/workflows/cuda.yaml
@@ -30,7 +30,7 @@ jobs:
       - uses: runs-on/action@v2
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-rust
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
@@ -38,12 +38,13 @@ jobs:
         with:
           command: >-
             cargo build --profile ci --locked --all-features --all-targets
-            -p vortex-cuda -p vortex-cub -p vortex-nvcomp
+            -p vortex-cuda -p vortex-cuda-ffi -p vortex-cub -p vortex-nvcomp
             -p gpu-scan-cli -p vortex-test-e2e-cuda
       - name: Clippy CUDA crates
         run: |
           cargo clippy --profile ci --locked --all-features --all-targets \
             -p vortex-cuda \
+            -p vortex-cuda-ffi \
             -p vortex-cub \
             -p vortex-nvcomp \
             -p gpu-scan-cli \
@@ -64,12 +65,12 @@ jobs:
           nvidia-smi
           nvidia-smi -L
           nvidia-smi -q -d Memory
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-rust
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
       - name: Install nextest
-        uses: taiki-e/install-action@e49978b799e49ff429d162b7a30601a569ab6538  # v2
+        uses: taiki-e/install-action@0631aa6515c7d545823c67cfae7ef4fc7f490154  # v2
         with:
           tool: nextest
       - name: Rust Tests
@@ -81,6 +82,7 @@ jobs:
             --locked \
             -p vortex-file \
             -p vortex-cuda \
+            -p vortex-cuda-ffi \
             -p vortex-cub \
             -p vortex-nvcomp \
             -p vortex-test-e2e-cuda \
@@ -116,7 +118,7 @@ jobs:
           nvidia-smi
           nvidia-smi -L
           nvidia-smi -q -d Memory
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-rust
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
@@ -141,7 +143,7 @@ jobs:
           nvidia-smi
           nvidia-smi -L
           nvidia-smi -q -d Memory
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-rust
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 506012f55ee..eadc0839c11 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-rust
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/fuzz-coverage.yml b/.github/workflows/fuzz-coverage.yml
index 005b06ef750..a62577313cc 100644
--- a/.github/workflows/fuzz-coverage.yml
+++ b/.github/workflows/fuzz-coverage.yml
@@ -26,7 +26,7 @@ jobs:
         with:
           sccache: s3
 
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
 
       - uses: ./.github/actions/setup-rust
         with:
diff --git a/.github/workflows/fuzzer-fix-automation.yml b/.github/workflows/fuzzer-fix-automation.yml
index e9b9db5c2cf..01df7162e78 100644
--- a/.github/workflows/fuzzer-fix-automation.yml
+++ b/.github/workflows/fuzzer-fix-automation.yml
@@ -63,7 +63,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
         with:
           # Don't leave the built-in GITHUB_TOKEN in git config; the fix is
           # committed and pushed with the App token so its PR triggers CI.
@@ -273,7 +273,7 @@ jobs:
           CRASH_FILE: ${{ steps.extract.outputs.crash_file }}
           CRASH_FILE_PATH: ${{ steps.download.outputs.crash_file_path }}
           ARTIFACT_URL: ${{ steps.extract.outputs.artifact_url }}
-        uses: anthropics/claude-code-action@787c5a0ce96a9a6cfb050ea0c8f4c05f2447c251  # v1
+        uses: anthropics/claude-code-action@fbda2eb1bdc90d319b8d853f5deb53bca199a7c1  # v1
         with:
           claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
           # Use the App token (not GITHUB_TOKEN) so the committed fix branch and
diff --git a/.github/workflows/minimize_fuzz_corpus_workflow.yml b/.github/workflows/minimize_fuzz_corpus_workflow.yml
index e3b2a9c11e6..f6c1e8d8df1 100644
--- a/.github/workflows/minimize_fuzz_corpus_workflow.yml
+++ b/.github/workflows/minimize_fuzz_corpus_workflow.yml
@@ -51,7 +51,7 @@ jobs:
         with:
           sccache: s3
 
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
 
       - uses: ./.github/actions/setup-rust
         with:
diff --git a/.github/workflows/musl.yml b/.github/workflows/musl.yml
index 13f5902db2e..cf8ff08eeb6 100644
--- a/.github/workflows/musl.yml
+++ b/.github/workflows/musl.yml
@@ -28,52 +28,48 @@ jobs:
       ${{ github.repository == 'vortex-data/vortex'
           && format('runs-on={0}/runner=amd64-large/image=ubuntu24-full-x64-pre-v2/tag=rust-build-musl', github.run_id)
           || 'ubuntu-latest' }}
+    container:
+      image: ghcr.io/rust-lang/rust:1-alpine3.21
+      credentials:
+        username: ${{ github.repository_owner }}
+        password: ${{ secrets.GITHUB_TOKEN }}
+    env:
+      # -crt-static makes build-script binaries dynamically linked so bindgen
+      # (custom-labels, a transitive dep of vortex-io) can dlopen libclang; a
+      # fully static musl build script panics with "Dynamic loading not supported".
+      RUSTFLAGS: "-A warnings -C target-feature=-crt-static"
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
-      # Build and test natively inside Alpine so the musl C/C++ toolchain (gcc, g++) and
-      # GNU ld are used. Cross-compiling from the glibc host is not viable: musl-tools
-      # ships no musl-g++ for C++ deps such as custom-labels, and zig's linker rejects the
-      # --dynamic-list arg those deps emit. Checkout runs on the host because JS actions
-      # cannot run inside an Alpine (musl) container, so this job provisions rustup +
-      # nextest itself rather than using the prebuilt toolchain / sccache setup that the
-      # glibc test runners use.
-      #
       # Exclusions:
       #   - CUDA crates have no CUDA toolkit / musl target (as in the wasm build).
       #   - vortex-duckdb and its dependents can't build standalone for musl: its
       #     build.rs has no prebuilt DuckDB for musl. The DuckDB extension builds it
       #     against a musl DuckDB it compiles itself, so it is exercised there instead.
-      - name: Build & test workspace for x86_64-unknown-linux-musl
+      - name: Install Alpine packages
+        # tzdata provides /usr/share/zoneinfo; without it Alpine has no timezone
+        # database and datetime tests fail with "failed to find time zone `UTC`".
         run: |
-          docker run --rm -v "${GITHUB_WORKSPACE}:/work" -w /work alpine:3.21 sh -euc '
-            # tzdata provides /usr/share/zoneinfo; without it Alpine has no timezone
-            # database and datetime tests fail with "failed to find time zone `UTC`".
-            apk add --no-cache build-base clang clang-dev llvm-dev cmake make perl \
-              pkgconf protobuf protobuf-dev openssl-dev zstd-dev bash git curl ca-certificates \
-              python3 python3-dev tar tzdata
-            # -crt-static makes build-script binaries dynamically linked so bindgen
-            # (custom-labels, a transitive dep of vortex-io) can dlopen libclang; a
-            # fully static musl build script panics with "Dynamic loading not supported".
-            export CARGO_HOME=/root/.cargo CARGO_TARGET_DIR=/tmp/target RUSTFLAGS="-A warnings -C target-feature=-crt-static"
-            export PATH="$CARGO_HOME/bin:$PATH"
-            curl --proto =https --tlsv1.2 -sSf https://sh.rustup.rs \
-              | sh -s -- -y --profile minimal --default-toolchain none
-            rustup show
-            # Prebuilt static musl nextest binary; building it from source would
-            # roughly double the cold-cache compile time of this job.
-            curl -LsSf https://get.nexte.st/latest/linux-musl \
-              | tar zxf - -C "$CARGO_HOME/bin"
-            # The workspace is bind-mounted from the host runner and owned by a
-            # different uid than the container root, so git rejects it as "dubious
-            # ownership" and `git rev-parse HEAD` returns empty. vortex-bench and the
-            # benchmarks website embed that SHA in snapshots (redacted to <commit-sha> /
-            # <build-sha>); an empty SHA breaks the redaction and fails 10 snapshot tests.
-            git config --global --add safe.directory /work
-            cargo nextest run --cargo-profile ci --locked --workspace --no-fail-fast \
-              --exclude vortex-cuda --exclude vortex-cub --exclude vortex-nvcomp \
-              --exclude gpu-scan-cli --exclude vortex-test-e2e-cuda \
-              --exclude vortex-duckdb --exclude duckdb-bench --exclude vortex-sqllogictest
-          '
+          apk add --no-cache build-base clang clang-dev llvm-dev cmake make perl \
+            pkgconf protobuf protobuf-dev openssl-dev zstd-dev git curl ca-certificates \
+            python3 python3-dev tar tzdata bash
+
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
+
+      - name: Install nextest
+        shell: bash
+        # Prebuilt static musl nextest binary; building it from source would
+        # roughly double the cold-cache compile time of this job.
+        run: |
+          curl -LsSf https://get.nexte.st/latest/linux-musl | tar zxf - -C ${CARGO_HOME:-~/.cargo}/bin
+
+      - name: Run workspace tests for x86_64-unknown-linux-musl
+        shell: bash
+        run: |
+          cargo nextest run --cargo-profile ci --locked --workspace --no-fail-fast \
+            --exclude vortex-cuda --exclude vortex-cub --exclude vortex-nvcomp \
+            --exclude gpu-scan-cli --exclude vortex-test-e2e-cuda \
+            --exclude vortex-duckdb --exclude duckdb-bench --exclude vortex-sqllogictest \
+            --exclude vortex-bench --exclude lance-bench --exclude datafusion-bench --exclude vortex-datafusion \
+            --exclude compress-bench --exclude random-access-bench --exclude vortex-bench-server
 
       - name: Alert incident.io
         if: failure() && github.event_name == 'push' && github.ref == 'refs/heads/develop'
diff --git a/.github/workflows/package.yml b/.github/workflows/package.yml
index 41bd61b9828..cc4e68d0eff 100644
--- a/.github/workflows/package.yml
+++ b/.github/workflows/package.yml
@@ -31,7 +31,7 @@ jobs:
           - { os: ubuntu, runs-on: "ubuntu-latest", target: aarch64-unknown-linux-gnu }
           - { os: ubuntu, runs-on: "ubuntu-latest", target: x86_64-unknown-linux-gnu }
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
         with:
           fetch-depth: 0
 
@@ -86,7 +86,7 @@ jobs:
     runs-on: "macos-latest"
     timeout-minutes: 30
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
         with:
           fetch-depth: 0
       - uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654  # v5
@@ -121,7 +121,7 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
         with:
           fetch-depth: 0
       - uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654  # v5
diff --git a/.github/workflows/publish-benchmarks-website.yml b/.github/workflows/publish-benchmarks-website.yml
index b73e176a79a..be1def626a0 100644
--- a/.github/workflows/publish-benchmarks-website.yml
+++ b/.github/workflows/publish-benchmarks-website.yml
@@ -14,7 +14,7 @@ jobs:
       contents: read
       packages: write
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
 
       - name: Log in to GHCR
         uses: docker/login-action@650006c6eb7dba73a995cc03b0b2d7f5ca915bee  # v4
diff --git a/.github/workflows/publish-dry-runs.yml b/.github/workflows/publish-dry-runs.yml
index 1da1b9322a7..7b6a750260b 100644
--- a/.github/workflows/publish-dry-runs.yml
+++ b/.github/workflows/publish-dry-runs.yml
@@ -27,7 +27,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - name: Rust Dependency Cache
         uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32  # v2
         with:
@@ -79,7 +79,7 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
         with:
           fetch-depth: 0
       - uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654  # v5
@@ -112,7 +112,7 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-prebuild
       - name: Install cargo-edit
         uses: taiki-e/cache-cargo-install-action@66c9585ef5ca780ee69399975a5e911f47905995
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index 010aee0bd80..6398c54c20e 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -23,7 +23,7 @@ jobs:
     timeout-minutes: 30
     needs: [package]
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
         with:
           fetch-depth: 0
       - uses: ./.github/actions/setup-rust
@@ -88,7 +88,7 @@ jobs:
       run:
         working-directory: ./java
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654  # v5
         with:
           distribution: "corretto"
diff --git a/.github/workflows/release-binaries.yml b/.github/workflows/release-binaries.yml
index 4d6620f85ed..64ecafd2e77 100644
--- a/.github/workflows/release-binaries.yml
+++ b/.github/workflows/release-binaries.yml
@@ -44,7 +44,7 @@ jobs:
         with:
           sccache: s3
 
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
         with:
           fetch-depth: 0
 
diff --git a/.github/workflows/report-fuzz-crash.yml b/.github/workflows/report-fuzz-crash.yml
index 3c5aef0b32e..ea68e9a832a 100644
--- a/.github/workflows/report-fuzz-crash.yml
+++ b/.github/workflows/report-fuzz-crash.yml
@@ -49,7 +49,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
 
       - name: Download fuzzer logs
         uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c  # v8
@@ -118,7 +118,7 @@ jobs:
           steps.dedup.outputs.duplicate != 'true' ||
           steps.dedup.outputs.confidence != 'exact'
         continue-on-error: true
-        uses: anthropics/claude-code-action@787c5a0ce96a9a6cfb050ea0c8f4c05f2447c251  # v1
+        uses: anthropics/claude-code-action@fbda2eb1bdc90d319b8d853f5deb53bca199a7c1  # v1
         with:
           claude_code_oauth_token: ${{ secrets.claude_code_oauth_token }}
           github_token: ${{ secrets.gh_token }}
diff --git a/.github/workflows/reuse.yml b/.github/workflows/reuse.yml
index 6d871fd20d4..3028dbbd8f1 100644
--- a/.github/workflows/reuse.yml
+++ b/.github/workflows/reuse.yml
@@ -17,6 +17,6 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - name: REUSE Compliance Check
         uses: fsfe/reuse-action@676e2d560c9a403aa252096d99fcab3e1132b0f5  # v6
diff --git a/.github/workflows/run-fuzzer.yml b/.github/workflows/run-fuzzer.yml
index 3ce424003e7..a3a41a1a53e 100644
--- a/.github/workflows/run-fuzzer.yml
+++ b/.github/workflows/run-fuzzer.yml
@@ -76,7 +76,7 @@ jobs:
         with:
           sccache: s3
 
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
 
       - uses: ./.github/actions/setup-rust
         with:
diff --git a/.github/workflows/rust-instrumented.yml b/.github/workflows/rust-instrumented.yml
index 1233021cf88..d58463d53d2 100644
--- a/.github/workflows/rust-instrumented.yml
+++ b/.github/workflows/rust-instrumented.yml
@@ -33,7 +33,7 @@ jobs:
           - suite: tests
     runs-on: >-
       ${{ github.repository == 'vortex-data/vortex'
-          && format('runs-on={0}/runner=amd64-large/image=ubuntu24-full-x64-pre-v2/tag=rust-coverage-suite-{1}', github.run_id, matrix.suite)
+          && format('runs-on={0}/runner=amd64-large/disk=large/image=ubuntu24-full-x64-pre-v2/tag=rust-coverage-suite-{1}', github.run_id, matrix.suite)
           || 'ubuntu-latest' }}
     env:
       RUSTFLAGS: "-Cinstrument-coverage -A warnings"
@@ -45,7 +45,7 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-prebuild
       - name: Ensure llvm-tools are installed
         run: |
@@ -86,7 +86,7 @@ jobs:
             -o ${{ env.GRCOV_OUTPUT_FILE }}
           test -s ${{ env.GRCOV_OUTPUT_FILE }}
       - name: Codecov
-        uses: codecov/codecov-action@e79a6962e0d4c0c17b229090214935d2e33f8354  # v6
+        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f  # v7
         with:
           name: run-${{ matrix.suite }}
           files: ${{ env.GRCOV_OUTPUT_FILE }}
@@ -128,7 +128,7 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-prebuild
       - name: Install Rust nightly toolchain
         run: |
@@ -137,27 +137,30 @@ jobs:
       - name: Build tests with sanitizer
         run: |
           RUSTFLAGS="${RUSTFLAGS} ${{ matrix.sanitizer_flags }}" \
-          cargo +$NIGHTLY_TOOLCHAIN build --locked --all-features \
+          cargo +$NIGHTLY_TOOLCHAIN build --tests --locked --all-features \
             --target x86_64-unknown-linux-gnu -Zbuild-std \
             -p vortex-buffer -p vortex-fastlanes -p vortex-fsst -p vortex-alp -p vortex-array
 
       - name: Run tests with sanitizer
         run: |
           RUSTFLAGS="${RUSTFLAGS} ${{ matrix.sanitizer_flags }}" \
-          cargo +$NIGHTLY_TOOLCHAIN nextest run --locked --all-features \
-            --target x86_64-unknown-linux-gnu --no-fail-fast -Zbuild-std \
+          cargo +$NIGHTLY_TOOLCHAIN nextest run --locked --all-features --no-fail-fast \
+            --target x86_64-unknown-linux-gnu -Zbuild-std \
             -p vortex-buffer -p vortex-fastlanes -p vortex-fsst -p vortex-alp -p vortex-array
 
         # vortex-ffi requires --no-default-features as otherwise we pull in
         # Mimalloc which interferes with sanitizers
         # cargo nextest reports less sanitizer issues than cargo test
         # TODO(myrrc): remove --no-default-features once we make Mimalloc opt-in
+        # --tests skips doctests: rustdoc ignores RUSTFLAGS (it uses RUSTDOCFLAGS),
+        # so doctests would build vortex-ffi without -Zsanitizer and mismatch the
+        # sanitizer-built deps.
       - name: Run vortex-ffi tests with sanitizer
         run: |
           RUSTFLAGS="${RUSTFLAGS} ${{ matrix.sanitizer_flags }}" \
           cargo +$NIGHTLY_TOOLCHAIN test --locked --no-default-features \
             --target x86_64-unknown-linux-gnu --no-fail-fast -Zbuild-std \
-            -p vortex-ffi -- --no-capture
+            -p vortex-ffi --tests -- --no-capture
 
   rust-ffi-test-sanitizer:
     strategy:
@@ -192,7 +195,7 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-prebuild
       - name: Install rustfilt
         run: |
@@ -211,8 +214,8 @@ jobs:
             --target x86_64-unknown-linux-gnu -Zbuild-std \
             -p vortex-ffi
       - name: Build FFI library tests and examples
+        working-directory: vortex-ffi
         run: |
-          cd vortex-ffi
           cmake -Bbuild -DBUILD_TESTS=1 -DBUILD_EXAMPLES=1 -DSANITIZER=${{ matrix.sanitizer }} -DTARGET_TRIPLE="x86_64-unknown-linux-gnu"
           cmake --build build -j
       - name: Run tests
@@ -249,7 +252,7 @@ jobs:
         if: github.repository == 'vortex-data/vortex'
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-prebuild
       - name: Install nightly with miri
         run: rustup toolchain install $NIGHTLY_TOOLCHAIN --component rust-src,rustfmt,clippy,miri
diff --git a/.github/workflows/sql-benchmarks.yml b/.github/workflows/sql-benchmarks.yml
index 48b17b9ac42..b46fe455a34 100644
--- a/.github/workflows/sql-benchmarks.yml
+++ b/.github/workflows/sql-benchmarks.yml
@@ -300,12 +300,12 @@ jobs:
         if: inputs.mode != 'pr' || github.event.pull_request.head.repo.fork == false
         with:
           sccache: s3
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
         if: inputs.mode == 'pr'
         with:
           ref: ${{ github.event.pull_request.head.sha }}
 
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
         if: inputs.mode != 'pr'
       - name: Setup benchmark environment
         run: sudo bash scripts/setup-benchmark.sh
@@ -362,7 +362,7 @@ jobs:
 
       - name: Setup AWS CLI
         if: inputs.mode != 'pr' || github.event.pull_request.head.repo.fork == false
-        uses: aws-actions/configure-aws-credentials@99214aa6889fcddfa57764031d71add364327e59  # v6
+        uses: aws-actions/configure-aws-credentials@e7f100cf4c008499ea8adda475de1042d6975c7b  # v6
         with:
           role-to-assume: arn:aws:iam::245040174862:role/GitHubBenchmarkRole
           aws-region: us-east-1
@@ -443,16 +443,8 @@ jobs:
         run: |
           set -Eeu -o pipefail -x
 
-          base_commit_sha=$(\
-            curl -L \
-              -H "Accept: application/vnd.github+json" \
-              -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" \
-              https://api.github.com/repos/vortex-data/vortex/actions/workflows/bench.yml/runs\?branch\=develop\&status\=success\&per_page\=1 \
-            | jq -r '.workflow_runs[].head_sha' \
-          )
-
           python3 scripts/s3-download.py s3://vortex-ci-benchmark-results/data.json.gz data.json.gz --no-sign-request
-          gzip -d -c data.json.gz | grep $base_commit_sha > base.json
+          gzip -d -c data.json.gz > base.json
 
           echo '# Benchmarks: ${{ matrix.name }}' > comment.md
           echo '' >> comment.md
diff --git a/.github/workflows/typos.yml b/.github/workflows/typos.yml
index b93dea673b1..e05120f8843 100644
--- a/.github/workflows/typos.yml
+++ b/.github/workflows/typos.yml
@@ -19,6 +19,6 @@ jobs:
     timeout-minutes: 10
     steps:
       - name: Checkout Actions Repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - name: Spell Check Repo
-        uses: crate-ci/typos@f8a58b6b53f2279f71eb605f03a4ae4d10608f45  # v1.47.0
+        uses: crate-ci/typos@37bb98842b0d8c4ffebdb75301a13db0267cef89  # v1.47.2
diff --git a/.github/workflows/v3-commit-metadata.yml b/.github/workflows/v3-commit-metadata.yml
index 9307cc394f9..d95da69207b 100644
--- a/.github/workflows/v3-commit-metadata.yml
+++ b/.github/workflows/v3-commit-metadata.yml
@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
         with:
           fetch-depth: 2
 
diff --git a/.github/workflows/wasm-fuzz.yml b/.github/workflows/wasm-fuzz.yml
index f076890c5b1..a2cec6c6c14 100644
--- a/.github/workflows/wasm-fuzz.yml
+++ b/.github/workflows/wasm-fuzz.yml
@@ -25,7 +25,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 240
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
 
       - uses: ./.github/actions/setup-rust
         with:
diff --git a/.github/workflows/web.yml b/.github/workflows/web.yml
index da0cdae16b6..cee88d0e43b 100644
--- a/.github/workflows/web.yml
+++ b/.github/workflows/web.yml
@@ -28,7 +28,7 @@ jobs:
     outputs:
       web: ${{ steps.filter.outputs.web }}
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: dorny/paths-filter@fbd0ab8f3e69293af611ebaee6363fc25e6d187d  # v4
         id: filter
         with:
@@ -44,7 +44,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-rust
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
@@ -71,7 +71,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6
       - uses: ./.github/actions/setup-rust
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/Cargo.lock b/Cargo.lock
index 8b66b77abfb..015f4a1b2d0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10,9 +10,9 @@ checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
 [[package]]
 name = "aes"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66bd29a732b644c0431c6140f370d097879203d79b80c94a6747ba0872adaef8"
+checksum = "f1fc76eaeac4c9164506c466d4ffdd8ec9d0c5bf57ee97177c4d8eceb3a0e138"
 dependencies = [
  "cipher",
  "cpubits",
@@ -145,35 +145,6 @@ version = "1.0.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 
-[[package]]
-name = "apache-avro"
-version = "0.21.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36fa98bc79671c7981272d91a8753a928ff6a1cd8e4f20a44c45bd5d313840bf"
-dependencies = [
- "bigdecimal",
- "bon",
- "bzip2",
- "crc32fast",
- "digest 0.10.7",
- "liblzma",
- "log",
- "miniz_oxide",
- "num-bigint",
- "quad-rand",
- "rand 0.9.4",
- "regex-lite",
- "serde",
- "serde_bytes",
- "serde_json",
- "snap",
- "strum 0.27.2",
- "strum_macros 0.27.2",
- "thiserror 2.0.18",
- "uuid",
- "zstd",
-]
-
 [[package]]
 name = "approx"
 version = "0.5.1"
@@ -197,9 +168,6 @@ name = "arbitrary"
 version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
-dependencies = [
- "derive_arbitrary",
-]
 
 [[package]]
 name = "arc-swap"
@@ -282,6 +250,30 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "arrow-avro"
+version = "58.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "049230728cd6e093088c8d231b4beede184e35cad7777c1505c0d5a8571f4376"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-schema",
+ "bytes",
+ "bzip2",
+ "crc",
+ "flate2",
+ "indexmap 2.14.0",
+ "liblzma",
+ "rand 0.9.4",
+ "serde",
+ "serde_json",
+ "snap",
+ "strum_macros 0.28.0",
+ "uuid",
+ "zstd",
+]
+
 [[package]]
 name = "arrow-buffer"
 version = "58.3.0"
@@ -515,7 +507,7 @@ dependencies = [
  "futures-lite",
  "parking",
  "polling",
- "rustix 1.1.4",
+ "rustix",
  "slab",
  "windows-sys 0.61.2",
 ]
@@ -557,7 +549,7 @@ dependencies = [
  "cfg-if",
  "event-listener",
  "futures-lite",
- "rustix 1.1.4",
+ "rustix",
 ]
 
 [[package]]
@@ -583,7 +575,7 @@ dependencies = [
  "cfg-if",
  "futures-core",
  "futures-io",
- "rustix 1.1.4",
+ "rustix",
  "signal-hook-registry",
  "slab",
  "windows-sys 0.61.2",
@@ -680,58 +672,6 @@ dependencies = [
  "fs_extra",
 ]
 
-[[package]]
-name = "axum"
-version = "0.8.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31b698c5f9a010f6573133b09e0de5408834d0c82f8d7475a89fc1867a71cd90"
-dependencies = [
- "axum-core",
- "bytes",
- "form_urlencoded",
- "futures-util",
- "http",
- "http-body",
- "http-body-util",
- "hyper",
- "hyper-util",
- "itoa",
- "matchit",
- "memchr",
- "mime",
- "percent-encoding",
- "pin-project-lite",
- "serde_core",
- "serde_json",
- "serde_path_to_error",
- "serde_urlencoded",
- "sync_wrapper",
- "tokio",
- "tower",
- "tower-layer",
- "tower-service",
- "tracing",
-]
-
-[[package]]
-name = "axum-core"
-version = "0.5.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08c78f31d7b1291f7ee735c1c6780ccde7785daae9a9206026862dab7d8792d1"
-dependencies = [
- "bytes",
- "futures-core",
- "http",
- "http-body",
- "http-body-util",
- "mime",
- "pin-project-lite",
- "sync_wrapper",
- "tower-layer",
- "tower-service",
- "tracing",
-]
-
 [[package]]
 name = "base16ct"
 version = "1.0.0"
@@ -787,7 +727,6 @@ dependencies = [
  "num-bigint",
  "num-integer",
  "num-traits",
- "serde",
 ]
 
 [[package]]
@@ -821,9 +760,9 @@ dependencies = [
 
 [[package]]
 name = "bitflags"
-version = "2.11.1"
+version = "2.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
+checksum = "b4388bee8683e3d04af747c73422af53102d2bd24d9eadb6cbc100baef4b43f8"
 
 [[package]]
 name = "bitpacking"
@@ -901,31 +840,6 @@ dependencies = [
  "piper",
 ]
 
-[[package]]
-name = "bon"
-version = "3.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f47dbe92550676ee653353c310dfb9cf6ba17ee70396e1f7cf0a2020ad49b2fe"
-dependencies = [
- "bon-macros",
- "rustversion",
-]
-
-[[package]]
-name = "bon-macros"
-version = "3.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "519bd3116aeeb42d5372c29d982d16d0170d3d4a5ed85fc7dd91642ffff3c67c"
-dependencies = [
- "darling",
- "ident_case",
- "prettyplease",
- "proc-macro2",
- "quote",
- "rustversion",
- "syn 2.0.117",
-]
-
 [[package]]
 name = "borsh"
 version = "1.6.1"
@@ -963,9 +877,9 @@ dependencies = [
 
 [[package]]
 name = "brotli-decompressor"
-version = "5.0.0"
+version = "5.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03"
+checksum = "5962523e1b92ce1b5e793d9169b9943eece10d39f62550bc04bb605d75b94924"
 dependencies = [
  "alloc-no-stdlib",
  "alloc-stdlib",
@@ -997,6 +911,12 @@ version = "3.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
 
+[[package]]
+name = "by_address"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64fa3c856b712db6612c019f14756e64e4bcea13337a6b33b696333a9eaa2d06"
+
 [[package]]
 name = "byte-slice-cast"
 version = "1.2.3"
@@ -1183,9 +1103,9 @@ dependencies = [
 
 [[package]]
 name = "chrono"
-version = "0.4.44"
+version = "0.4.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
+checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327"
 dependencies = [
  "iana-time-zone",
  "js-sys",
@@ -1305,9 +1225,9 @@ dependencies = [
 
 [[package]]
 name = "cmov"
-version = "0.5.3"
+version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f88a43d011fc4a6876cb7344703e297c71dda42494fee094d5f7c76bf13f746"
+checksum = "0c9ea0ac24bc397ab3c98583a3c9ba74fa56b09a4449bbe172b9b1ddb016027a"
 
 [[package]]
 name = "codespan-reporting"
@@ -1439,16 +1359,15 @@ version = "7.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4a65ebfec4fb190b6f90e944a817d60499ee0744e582530e2c9900a22e591d9a"
 dependencies = [
- "crossterm 0.28.1",
  "unicode-segmentation",
  "unicode-width 0.2.2",
 ]
 
 [[package]]
 name = "compact_str"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb1325a1cece981e8a296ab8f0f9b63ae357bd0784a9faaf548cc7b480707a"
+checksum = "9dfdd1c2274d9aa354115b09dc9a901d6c5576818cdf70d14cae2bdb47df00ab"
 dependencies = [
  "castaway",
  "cfg-if",
@@ -1486,7 +1405,6 @@ version = "0.4.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ce2548391e9c1929c21bf6aa2680af86fe4c1b33e6cea9ac1cfeec0bd11218cf"
 dependencies = [
- "brotli",
  "bzip2",
  "compression-core",
  "flate2",
@@ -1645,6 +1563,12 @@ version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
+[[package]]
+name = "core_detect"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f8f80099a98041a3d1622845c271458a2d73e688351bf3cb999266764b81d48"
+
 [[package]]
 name = "cpubits"
 version = "0.1.1"
@@ -1669,6 +1593,21 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "crc"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5eb8a2a1cd12ab0d987a5d5e825195d372001a4094a0376319d5a0ad71c1ba0d"
+dependencies = [
+ "crc-catalog",
+]
+
+[[package]]
+name = "crc-catalog"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "217698eaf96b4a3f0bc4f3662aaa55bdf913cd54d7204591faa790070c6d0853"
+
 [[package]]
 name = "crc32fast"
 version = "1.5.0"
@@ -1688,6 +1627,12 @@ dependencies = [
  "itertools 0.10.5",
 ]
 
+[[package]]
+name = "critical-section"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b"
+
 [[package]]
 name = "crossbeam-channel"
 version = "0.5.15"
@@ -1741,19 +1686,6 @@ version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
-[[package]]
-name = "crossterm"
-version = "0.28.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "829d955a0bb380ef178a640b91779e3987da38c9aea133b20614cfed8cdea9c6"
-dependencies = [
- "bitflags",
- "crossterm_winapi",
- "parking_lot",
- "rustix 0.38.44",
- "winapi",
-]
-
 [[package]]
 name = "crossterm"
 version = "0.29.0"
@@ -1767,7 +1699,7 @@ dependencies = [
  "futures-core",
  "mio",
  "parking_lot",
- "rustix 1.1.4",
+ "rustix",
  "signal-hook",
  "signal-hook-mio",
  "winapi",
@@ -1979,45 +1911,92 @@ dependencies = [
  "arrow-schema",
  "async-trait",
  "bytes",
+ "chrono",
+ "datafusion-catalog 53.1.0",
+ "datafusion-catalog-listing 53.1.0",
+ "datafusion-common 53.1.0",
+ "datafusion-common-runtime 53.1.0",
+ "datafusion-datasource 53.1.0",
+ "datafusion-datasource-arrow 53.1.0",
+ "datafusion-datasource-csv 53.1.0",
+ "datafusion-datasource-json 53.1.0",
+ "datafusion-execution 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-expr-common 53.1.0",
+ "datafusion-functions 53.1.0",
+ "datafusion-functions-aggregate 53.1.0",
+ "datafusion-functions-nested 53.1.0",
+ "datafusion-functions-table 53.1.0",
+ "datafusion-functions-window 53.1.0",
+ "datafusion-optimizer 53.1.0",
+ "datafusion-physical-expr 53.1.0",
+ "datafusion-physical-expr-adapter 53.1.0",
+ "datafusion-physical-expr-common 53.1.0",
+ "datafusion-physical-optimizer 53.1.0",
+ "datafusion-physical-plan 53.1.0",
+ "datafusion-session 53.1.0",
+ "datafusion-sql 53.1.0",
+ "futures",
+ "itertools 0.14.0",
+ "log",
+ "object_store 0.13.2",
+ "parking_lot",
+ "rand 0.9.4",
+ "regex",
+ "sqlparser 0.61.0",
+ "tempfile",
+ "tokio",
+ "url",
+ "uuid",
+]
+
+[[package]]
+name = "datafusion"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "997a31e15872606a49478e670c58302094c97cb96abb0a7d60720f8e92170040"
+dependencies = [
+ "arrow",
+ "arrow-schema",
+ "async-trait",
  "bzip2",
  "chrono",
- "datafusion-catalog",
- "datafusion-catalog-listing",
- "datafusion-common",
- "datafusion-common-runtime",
- "datafusion-datasource",
- "datafusion-datasource-arrow",
+ "datafusion-catalog 54.0.0",
+ "datafusion-catalog-listing 54.0.0",
+ "datafusion-common 54.0.0",
+ "datafusion-common-runtime 54.0.0",
+ "datafusion-datasource 54.0.0",
+ "datafusion-datasource-arrow 54.0.0",
  "datafusion-datasource-avro",
- "datafusion-datasource-csv",
- "datafusion-datasource-json",
+ "datafusion-datasource-csv 54.0.0",
+ "datafusion-datasource-json 54.0.0",
  "datafusion-datasource-parquet",
- "datafusion-execution",
- "datafusion-expr",
- "datafusion-expr-common",
- "datafusion-functions",
- "datafusion-functions-aggregate",
- "datafusion-functions-nested",
- "datafusion-functions-table",
- "datafusion-functions-window",
- "datafusion-optimizer",
- "datafusion-physical-expr",
- "datafusion-physical-expr-adapter",
- "datafusion-physical-expr-common",
- "datafusion-physical-optimizer",
- "datafusion-physical-plan",
- "datafusion-session",
- "datafusion-sql",
+ "datafusion-execution 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-expr-common 54.0.0",
+ "datafusion-functions 54.0.0",
+ "datafusion-functions-aggregate 54.0.0",
+ "datafusion-functions-nested 54.0.0",
+ "datafusion-functions-table 54.0.0",
+ "datafusion-functions-window 54.0.0",
+ "datafusion-optimizer 54.0.0",
+ "datafusion-physical-expr 54.0.0",
+ "datafusion-physical-expr-adapter 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
+ "datafusion-physical-optimizer 54.0.0",
+ "datafusion-physical-plan 54.0.0",
+ "datafusion-session 54.0.0",
+ "datafusion-sql 54.0.0",
  "flate2",
  "futures",
+ "indexmap 2.14.0",
  "itertools 0.14.0",
  "liblzma",
  "log",
  "object_store 0.13.2",
  "parking_lot",
  "parquet",
- "rand 0.9.4",
- "regex",
- "sqlparser",
+ "sqlparser 0.62.0",
  "tempfile",
  "tokio",
  "url",
@@ -2032,9 +2011,9 @@ dependencies = [
  "anyhow",
  "clap",
  "custom-labels",
- "datafusion",
- "datafusion-common",
- "datafusion-physical-plan",
+ "datafusion 54.0.0",
+ "datafusion-common 54.0.0",
+ "datafusion-physical-plan 54.0.0",
  "futures",
  "itertools 0.14.0",
  "object_store 0.13.2",
@@ -2060,14 +2039,39 @@ dependencies = [
  "arrow",
  "async-trait",
  "dashmap",
- "datafusion-common",
- "datafusion-common-runtime",
- "datafusion-datasource",
- "datafusion-execution",
- "datafusion-expr",
- "datafusion-physical-expr",
- "datafusion-physical-plan",
- "datafusion-session",
+ "datafusion-common 53.1.0",
+ "datafusion-common-runtime 53.1.0",
+ "datafusion-datasource 53.1.0",
+ "datafusion-execution 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-physical-expr 53.1.0",
+ "datafusion-physical-plan 53.1.0",
+ "datafusion-session 53.1.0",
+ "futures",
+ "itertools 0.14.0",
+ "log",
+ "object_store 0.13.2",
+ "parking_lot",
+ "tokio",
+]
+
+[[package]]
+name = "datafusion-catalog"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7dd61161508f8f5fa1107774ea687bd753c22d83a32eebf963549f89de14139"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "dashmap",
+ "datafusion-common 54.0.0",
+ "datafusion-common-runtime 54.0.0",
+ "datafusion-datasource 54.0.0",
+ "datafusion-execution 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-physical-expr 54.0.0",
+ "datafusion-physical-plan 54.0.0",
+ "datafusion-session 54.0.0",
  "futures",
  "itertools 0.14.0",
  "log",
@@ -2084,15 +2088,38 @@ checksum = "17e112307715d6a7a331111a4c2330ff54bc237183511c319e3708a4cff431fb"
 dependencies = [
  "arrow",
  "async-trait",
- "datafusion-catalog",
- "datafusion-common",
- "datafusion-datasource",
- "datafusion-execution",
- "datafusion-expr",
- "datafusion-physical-expr",
- "datafusion-physical-expr-adapter",
- "datafusion-physical-expr-common",
- "datafusion-physical-plan",
+ "datafusion-catalog 53.1.0",
+ "datafusion-common 53.1.0",
+ "datafusion-datasource 53.1.0",
+ "datafusion-execution 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-physical-expr 53.1.0",
+ "datafusion-physical-expr-adapter 53.1.0",
+ "datafusion-physical-expr-common 53.1.0",
+ "datafusion-physical-plan 53.1.0",
+ "futures",
+ "itertools 0.14.0",
+ "log",
+ "object_store 0.13.2",
+]
+
+[[package]]
+name = "datafusion-catalog-listing"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "897c70f871277f9ce99aa38347be0d679bbe3e617156c4d2a8378cec8a2a0891"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "datafusion-catalog 54.0.0",
+ "datafusion-common 54.0.0",
+ "datafusion-datasource 54.0.0",
+ "datafusion-execution 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-physical-expr 54.0.0",
+ "datafusion-physical-expr-adapter 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
+ "datafusion-physical-plan 54.0.0",
  "futures",
  "itertools 0.14.0",
  "log",
@@ -2106,7 +2133,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d72a11ca44a95e1081870d3abb80c717496e8a7acb467a1d3e932bb636af5cc2"
 dependencies = [
  "ahash 0.8.12",
- "apache-avro",
  "arrow",
  "arrow-ipc",
  "chrono",
@@ -2117,11 +2143,35 @@ dependencies = [
  "libc",
  "log",
  "object_store 0.13.2",
- "parquet",
  "paste",
+ "sqlparser 0.61.0",
+ "tokio",
+ "web-time",
+]
+
+[[package]]
+name = "datafusion-common"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "121c9ded5d87d9172319e006f2afdb9928d72dbacd6a90a458d8acb1e3b43a65"
+dependencies = [
+ "arrow",
+ "arrow-ipc",
+ "arrow-schema",
+ "chrono",
+ "foldhash 0.2.0",
+ "half",
+ "hashbrown 0.17.1",
+ "indexmap 2.14.0",
+ "itertools 0.14.0",
+ "libc",
+ "log",
+ "object_store 0.13.2",
+ "parquet",
  "recursive",
- "sqlparser",
+ "sqlparser 0.62.0",
  "tokio",
+ "uuid",
  "web-time",
 ]
 
@@ -2136,11 +2186,51 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "datafusion-common-runtime"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "981b9dae74f78ee3d9f714fb49b01919eab975461b56149510c3ba9ea11287d1"
+dependencies = [
+ "futures",
+ "log",
+ "tokio",
+]
+
 [[package]]
 name = "datafusion-datasource"
 version = "53.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e9fb386e1691355355a96419978a0022b7947b44d4a24a6ea99f00b6b485cbb6"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "bytes",
+ "chrono",
+ "datafusion-common 53.1.0",
+ "datafusion-common-runtime 53.1.0",
+ "datafusion-execution 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-physical-expr 53.1.0",
+ "datafusion-physical-expr-adapter 53.1.0",
+ "datafusion-physical-expr-common 53.1.0",
+ "datafusion-physical-plan 53.1.0",
+ "datafusion-session 53.1.0",
+ "futures",
+ "glob",
+ "itertools 0.14.0",
+ "log",
+ "object_store 0.13.2",
+ "rand 0.9.4",
+ "tokio",
+ "url",
+]
+
+[[package]]
+name = "datafusion-datasource"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffd7d295b2ec7c00d8a56562f41ed41062cf0af75549ed891c12a0a09eddfefe"
 dependencies = [
  "arrow",
  "async-compression",
@@ -2148,15 +2238,15 @@ dependencies = [
  "bytes",
  "bzip2",
  "chrono",
- "datafusion-common",
- "datafusion-common-runtime",
- "datafusion-execution",
- "datafusion-expr",
- "datafusion-physical-expr",
- "datafusion-physical-expr-adapter",
- "datafusion-physical-expr-common",
- "datafusion-physical-plan",
- "datafusion-session",
+ "datafusion-common 54.0.0",
+ "datafusion-common-runtime 54.0.0",
+ "datafusion-execution 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-physical-expr 54.0.0",
+ "datafusion-physical-expr-adapter 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
+ "datafusion-physical-plan 54.0.0",
+ "datafusion-session 54.0.0",
  "flate2",
  "futures",
  "glob",
@@ -2164,6 +2254,7 @@ dependencies = [
  "liblzma",
  "log",
  "object_store 0.13.2",
+ "parking_lot",
  "rand 0.9.4",
  "tokio",
  "tokio-util",
@@ -2181,14 +2272,14 @@ dependencies = [
  "arrow-ipc",
  "async-trait",
  "bytes",
- "datafusion-common",
- "datafusion-common-runtime",
- "datafusion-datasource",
- "datafusion-execution",
- "datafusion-expr",
- "datafusion-physical-expr-common",
- "datafusion-physical-plan",
- "datafusion-session",
+ "datafusion-common 53.1.0",
+ "datafusion-common-runtime 53.1.0",
+ "datafusion-datasource 53.1.0",
+ "datafusion-execution 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-physical-expr-common 53.1.0",
+ "datafusion-physical-plan 53.1.0",
+ "datafusion-session 53.1.0",
  "futures",
  "itertools 0.14.0",
  "object_store 0.13.2",
@@ -2196,22 +2287,45 @@ dependencies = [
 ]
 
 [[package]]
-name = "datafusion-datasource-avro"
-version = "53.1.0"
+name = "datafusion-datasource-arrow"
+version = "54.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a579c3bd290c66ea4b269493e75e8a3ed42c9c895a651f10210a29538aee50c4"
+checksum = "552b0b3f342f7ec41b3fbd70f6339dc82a30cfd0349e7f280e7852528085349f"
 dependencies = [
- "apache-avro",
  "arrow",
+ "arrow-ipc",
  "async-trait",
  "bytes",
- "datafusion-common",
- "datafusion-datasource",
- "datafusion-physical-expr-common",
- "datafusion-physical-plan",
- "datafusion-session",
+ "datafusion-common 54.0.0",
+ "datafusion-common-runtime 54.0.0",
+ "datafusion-datasource 54.0.0",
+ "datafusion-execution 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
+ "datafusion-physical-plan 54.0.0",
+ "datafusion-session 54.0.0",
+ "futures",
+ "itertools 0.14.0",
+ "object_store 0.13.2",
+ "tokio",
+]
+
+[[package]]
+name = "datafusion-datasource-avro"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb517d08967d536284ce70afb5fe8583133779249f2d7b90587d339741a7f195"
+dependencies = [
+ "arrow",
+ "arrow-avro",
+ "async-trait",
+ "bytes",
+ "datafusion-common 54.0.0",
+ "datafusion-datasource 54.0.0",
+ "datafusion-physical-expr-adapter 54.0.0",
+ "datafusion-physical-plan 54.0.0",
+ "datafusion-session 54.0.0",
  "futures",
- "num-traits",
  "object_store 0.13.2",
 ]
 
@@ -2224,14 +2338,37 @@ dependencies = [
  "arrow",
  "async-trait",
  "bytes",
- "datafusion-common",
- "datafusion-common-runtime",
- "datafusion-datasource",
- "datafusion-execution",
- "datafusion-expr",
- "datafusion-physical-expr-common",
- "datafusion-physical-plan",
- "datafusion-session",
+ "datafusion-common 53.1.0",
+ "datafusion-common-runtime 53.1.0",
+ "datafusion-datasource 53.1.0",
+ "datafusion-execution 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-physical-expr-common 53.1.0",
+ "datafusion-physical-plan 53.1.0",
+ "datafusion-session 53.1.0",
+ "futures",
+ "object_store 0.13.2",
+ "regex",
+ "tokio",
+]
+
+[[package]]
+name = "datafusion-datasource-csv"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68850aa426b897e879c8b87e512ea8124f1d0a2869a4e51808ddaaddf1bc0ada"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "bytes",
+ "datafusion-common 54.0.0",
+ "datafusion-common-runtime 54.0.0",
+ "datafusion-datasource 54.0.0",
+ "datafusion-execution 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
+ "datafusion-physical-plan 54.0.0",
+ "datafusion-session 54.0.0",
  "futures",
  "object_store 0.13.2",
  "regex",
@@ -2247,14 +2384,14 @@ dependencies = [
  "arrow",
  "async-trait",
  "bytes",
- "datafusion-common",
- "datafusion-common-runtime",
- "datafusion-datasource",
- "datafusion-execution",
- "datafusion-expr",
- "datafusion-physical-expr-common",
- "datafusion-physical-plan",
- "datafusion-session",
+ "datafusion-common 53.1.0",
+ "datafusion-common-runtime 53.1.0",
+ "datafusion-datasource 53.1.0",
+ "datafusion-execution 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-physical-expr-common 53.1.0",
+ "datafusion-physical-plan 53.1.0",
+ "datafusion-session 53.1.0",
  "futures",
  "object_store 0.13.2",
  "serde_json",
@@ -2262,27 +2399,51 @@ dependencies = [
  "tokio-stream",
 ]
 
+[[package]]
+name = "datafusion-datasource-json"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "402f93242ae08ef99139ee2c528a49d087efe88d5c7b2c3ff5480855a40ce54f"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "bytes",
+ "datafusion-common 54.0.0",
+ "datafusion-common-runtime 54.0.0",
+ "datafusion-datasource 54.0.0",
+ "datafusion-execution 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
+ "datafusion-physical-plan 54.0.0",
+ "datafusion-session 54.0.0",
+ "futures",
+ "object_store 0.13.2",
+ "tokio",
+ "tokio-stream",
+]
+
 [[package]]
 name = "datafusion-datasource-parquet"
-version = "53.1.0"
+version = "54.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a8e0365e0e08e8ff94d912f0ababcf9065a1a304018ba90b1fc83c855b4997"
+checksum = "ffd2499c1bee0eeccf6a57156105700eeeb17bc701899ac719183c4e74231450"
 dependencies = [
  "arrow",
  "async-trait",
  "bytes",
- "datafusion-common",
- "datafusion-common-runtime",
- "datafusion-datasource",
- "datafusion-execution",
- "datafusion-expr",
- "datafusion-functions-aggregate-common",
- "datafusion-physical-expr",
- "datafusion-physical-expr-adapter",
- "datafusion-physical-expr-common",
- "datafusion-physical-plan",
- "datafusion-pruning",
- "datafusion-session",
+ "datafusion-common 54.0.0",
+ "datafusion-common-runtime 54.0.0",
+ "datafusion-datasource 54.0.0",
+ "datafusion-execution 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-functions 54.0.0",
+ "datafusion-functions-aggregate-common 54.0.0",
+ "datafusion-physical-expr 54.0.0",
+ "datafusion-physical-expr-adapter 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
+ "datafusion-physical-plan 54.0.0",
+ "datafusion-pruning 54.0.0",
+ "datafusion-session 54.0.0",
  "futures",
  "itertools 0.14.0",
  "log",
@@ -2298,6 +2459,12 @@ version = "53.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8de6ac0df1662b9148ad3c987978b32cbec7c772f199b1d53520c8fa764a87ee"
 
+[[package]]
+name = "datafusion-doc"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb9e7e5d11130c48c8bd4e80c79a9772dd28ce6dc330baca9246205d245b9e2e"
+
 [[package]]
 name = "datafusion-execution"
 version = "53.1.0"
@@ -2309,9 +2476,31 @@ dependencies = [
  "async-trait",
  "chrono",
  "dashmap",
- "datafusion-common",
- "datafusion-expr",
- "datafusion-physical-expr-common",
+ "datafusion-common 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-physical-expr-common 53.1.0",
+ "futures",
+ "log",
+ "object_store 0.13.2",
+ "parking_lot",
+ "rand 0.9.4",
+ "tempfile",
+ "url",
+]
+
+[[package]]
+name = "datafusion-execution"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37a8643ab852eb68864e1b72ae789e8066282dce48eea6347ffb0aee33d1ccc0"
+dependencies = [
+ "arrow",
+ "arrow-buffer",
+ "async-trait",
+ "dashmap",
+ "datafusion-common 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
  "futures",
  "log",
  "object_store 0.13.2",
@@ -2330,18 +2519,40 @@ dependencies = [
  "arrow",
  "async-trait",
  "chrono",
- "datafusion-common",
- "datafusion-doc",
- "datafusion-expr-common",
- "datafusion-functions-aggregate-common",
- "datafusion-functions-window-common",
- "datafusion-physical-expr-common",
+ "datafusion-common 53.1.0",
+ "datafusion-doc 53.1.0",
+ "datafusion-expr-common 53.1.0",
+ "datafusion-functions-aggregate-common 53.1.0",
+ "datafusion-functions-window-common 53.1.0",
+ "datafusion-physical-expr-common 53.1.0",
  "indexmap 2.14.0",
  "itertools 0.14.0",
  "paste",
+ "serde_json",
+ "sqlparser 0.61.0",
+]
+
+[[package]]
+name = "datafusion-expr"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6932f4d71eed9c8d9341476a2b845aadfabde5495d08dbcd8fc23881f49fa7a0"
+dependencies = [
+ "arrow",
+ "arrow-schema",
+ "async-trait",
+ "chrono",
+ "datafusion-common 54.0.0",
+ "datafusion-doc 54.0.0",
+ "datafusion-expr-common 54.0.0",
+ "datafusion-functions-aggregate-common 54.0.0",
+ "datafusion-functions-window-common 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
+ "indexmap 2.14.0",
+ "itertools 0.14.0",
  "recursive",
  "serde_json",
- "sqlparser",
+ "sqlparser 0.62.0",
 ]
 
 [[package]]
@@ -2351,12 +2562,24 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7d7c3adf3db8bf61e92eb90cb659c8e8b734593a8f7c8e12a843c7ddba24b87e"
 dependencies = [
  "arrow",
- "datafusion-common",
+ "datafusion-common 53.1.0",
  "indexmap 2.14.0",
  "itertools 0.14.0",
  "paste",
 ]
 
+[[package]]
+name = "datafusion-expr-common"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0225491839a31b1f7d2cb8092c2d50792e2fe1c1724e4e6d08e011f5feaf4ed2"
+dependencies = [
+ "arrow",
+ "datafusion-common 54.0.0",
+ "indexmap 2.14.0",
+ "itertools 0.14.0",
+]
+
 [[package]]
 name = "datafusion-functions"
 version = "53.1.0"
@@ -2370,16 +2593,16 @@ dependencies = [
  "blake3",
  "chrono",
  "chrono-tz",
- "datafusion-common",
- "datafusion-doc",
- "datafusion-execution",
- "datafusion-expr",
- "datafusion-expr-common",
- "datafusion-macros",
+ "datafusion-common 53.1.0",
+ "datafusion-doc 53.1.0",
+ "datafusion-execution 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-expr-common 53.1.0",
+ "datafusion-macros 53.1.0",
  "hex",
  "itertools 0.14.0",
  "log",
- "md-5",
+ "md-5 0.10.6",
  "memchr",
  "num-traits",
  "rand 0.9.4",
@@ -2389,6 +2612,38 @@ dependencies = [
  "uuid",
 ]
 
+[[package]]
+name = "datafusion-functions"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14872c47bfc3d21e53ec82f57074e6987a15941c1e2f43cde4ac6ae2746634e3"
+dependencies = [
+ "arrow",
+ "arrow-buffer",
+ "base64",
+ "blake2",
+ "blake3",
+ "chrono",
+ "chrono-tz",
+ "datafusion-common 54.0.0",
+ "datafusion-doc 54.0.0",
+ "datafusion-execution 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-expr-common 54.0.0",
+ "datafusion-macros 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
+ "hex",
+ "itertools 0.14.0",
+ "log",
+ "md-5 0.11.0",
+ "memchr",
+ "num-traits",
+ "rand 0.9.4",
+ "regex",
+ "sha2 0.11.0",
+ "uuid",
+]
+
 [[package]]
 name = "datafusion-functions-aggregate"
 version = "53.1.0"
@@ -2397,20 +2652,41 @@ checksum = "00aa6217e56098ba84e0a338176fe52f0a84cca398021512c6c8c5eff806d0ad"
 dependencies = [
  "ahash 0.8.12",
  "arrow",
- "datafusion-common",
- "datafusion-doc",
- "datafusion-execution",
- "datafusion-expr",
- "datafusion-functions-aggregate-common",
- "datafusion-macros",
- "datafusion-physical-expr",
- "datafusion-physical-expr-common",
+ "datafusion-common 53.1.0",
+ "datafusion-doc 53.1.0",
+ "datafusion-execution 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-functions-aggregate-common 53.1.0",
+ "datafusion-macros 53.1.0",
+ "datafusion-physical-expr 53.1.0",
+ "datafusion-physical-expr-common 53.1.0",
  "half",
  "log",
  "num-traits",
  "paste",
 ]
 
+[[package]]
+name = "datafusion-functions-aggregate"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75a2ca14e1b609be21e657e2d3130b2f446456b08393b377bb721a33952d2e09"
+dependencies = [
+ "arrow",
+ "datafusion-common 54.0.0",
+ "datafusion-doc 54.0.0",
+ "datafusion-execution 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-functions-aggregate-common 54.0.0",
+ "datafusion-macros 54.0.0",
+ "datafusion-physical-expr 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
+ "foldhash 0.2.0",
+ "half",
+ "log",
+ "num-traits",
+]
+
 [[package]]
 name = "datafusion-functions-aggregate-common"
 version = "53.1.0"
@@ -2419,9 +2695,21 @@ checksum = "b511250349407db7c43832ab2de63f5557b19a20dfd236b39ca2c04468b50d47"
 dependencies = [
  "ahash 0.8.12",
  "arrow",
- "datafusion-common",
- "datafusion-expr-common",
- "datafusion-physical-expr-common",
+ "datafusion-common 53.1.0",
+ "datafusion-expr-common 53.1.0",
+ "datafusion-physical-expr-common 53.1.0",
+]
+
+[[package]]
+name = "datafusion-functions-aggregate-common"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ece74ba09092d2ef9c9b54a38445450aea292a1f8b04faf531936b723a24b3c"
+dependencies = [
+ "arrow",
+ "datafusion-common 54.0.0",
+ "datafusion-expr-common 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
 ]
 
 [[package]]
@@ -2432,16 +2720,16 @@ checksum = "ef13a858e20d50f0a9bb5e96e7ac82b4e7597f247515bccca4fdd2992df0212a"
 dependencies = [
  "arrow",
  "arrow-ord",
- "datafusion-common",
- "datafusion-doc",
- "datafusion-execution",
- "datafusion-expr",
- "datafusion-expr-common",
- "datafusion-functions",
- "datafusion-functions-aggregate",
- "datafusion-functions-aggregate-common",
- "datafusion-macros",
- "datafusion-physical-expr-common",
+ "datafusion-common 53.1.0",
+ "datafusion-doc 53.1.0",
+ "datafusion-execution 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-expr-common 53.1.0",
+ "datafusion-functions 53.1.0",
+ "datafusion-functions-aggregate 53.1.0",
+ "datafusion-functions-aggregate-common 53.1.0",
+ "datafusion-macros 53.1.0",
+ "datafusion-physical-expr-common 53.1.0",
  "hashbrown 0.16.1",
  "itertools 0.14.0",
  "itoa",
@@ -2449,6 +2737,31 @@ dependencies = [
  "paste",
 ]
 
+[[package]]
+name = "datafusion-functions-nested"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f3e3f9ee8ca59bf70518802107de6f1b88a9509efdc629fadc5de9d6b2d5ef5"
+dependencies = [
+ "arrow",
+ "arrow-ord",
+ "datafusion-common 54.0.0",
+ "datafusion-doc 54.0.0",
+ "datafusion-execution 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-expr-common 54.0.0",
+ "datafusion-functions 54.0.0",
+ "datafusion-functions-aggregate 54.0.0",
+ "datafusion-functions-aggregate-common 54.0.0",
+ "datafusion-macros 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
+ "hashbrown 0.17.1",
+ "itertools 0.14.0",
+ "itoa",
+ "log",
+ "memchr",
+]
+
 [[package]]
 name = "datafusion-functions-table"
 version = "53.1.0"
@@ -2457,14 +2770,30 @@ checksum = "72b40d3f5bbb3905f9ccb1ce9485a9595c77b69758a7c24d3ba79e334ff51e7e"
 dependencies = [
  "arrow",
  "async-trait",
- "datafusion-catalog",
- "datafusion-common",
- "datafusion-expr",
- "datafusion-physical-plan",
+ "datafusion-catalog 53.1.0",
+ "datafusion-common 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-physical-plan 53.1.0",
  "parking_lot",
  "paste",
 ]
 
+[[package]]
+name = "datafusion-functions-table"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89161dffc22cf2b50f9f4b1bee83b5221d3b4ed7c2e37fd7aa2b22a5297b3a26"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "datafusion-catalog 54.0.0",
+ "datafusion-common 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-physical-expr 54.0.0",
+ "datafusion-physical-plan 54.0.0",
+ "parking_lot",
+]
+
 [[package]]
 name = "datafusion-functions-window"
 version = "53.1.0"
@@ -2472,25 +2801,52 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d4e88ec9d57c9b685d02f58bfee7be62d72610430ddcedb82a08e5d9925dbfb6"
 dependencies = [
  "arrow",
- "datafusion-common",
- "datafusion-doc",
- "datafusion-expr",
- "datafusion-functions-window-common",
- "datafusion-macros",
- "datafusion-physical-expr",
- "datafusion-physical-expr-common",
+ "datafusion-common 53.1.0",
+ "datafusion-doc 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-functions-window-common 53.1.0",
+ "datafusion-macros 53.1.0",
+ "datafusion-physical-expr 53.1.0",
+ "datafusion-physical-expr-common 53.1.0",
  "log",
  "paste",
 ]
 
+[[package]]
+name = "datafusion-functions-window"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7339345b226b3874037708bf5023ba1c2de705128f8457a095aae5ae9cb9c78"
+dependencies = [
+ "arrow",
+ "datafusion-common 54.0.0",
+ "datafusion-doc 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-functions-window-common 54.0.0",
+ "datafusion-macros 54.0.0",
+ "datafusion-physical-expr 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
+ "log",
+]
+
 [[package]]
 name = "datafusion-functions-window-common"
 version = "53.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8307bb93519b1a91913723a1130cfafeee3f72200d870d88e91a6fc5470ede5c"
 dependencies = [
- "datafusion-common",
- "datafusion-physical-expr-common",
+ "datafusion-common 53.1.0",
+ "datafusion-physical-expr-common 53.1.0",
+]
+
+[[package]]
+name = "datafusion-functions-window-common"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa84836dc2392df6f43d6a29d37fb56a8ebdc8b3f4e10ae8dc15861fd20278fb"
+dependencies = [
+ "datafusion-common 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
 ]
 
 [[package]]
@@ -2499,7 +2855,18 @@ version = "53.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2e367e6a71051d0ebdd29b2f85d12059b38b1d1f172c6906e80016da662226bd"
 dependencies = [
- "datafusion-doc",
+ "datafusion-doc 53.1.0",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "datafusion-macros"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "587164e03ad68732aa9e7bfe5686e3f25970d4c64fd4bd80790749840892dae5"
+dependencies = [
+ "datafusion-doc 54.0.0",
  "quote",
  "syn 2.0.117",
 ]
@@ -2512,10 +2879,29 @@ checksum = "e929015451a67f77d9d8b727b2bf3a40c4445fdef6cdc53281d7d97c76888ace"
 dependencies = [
  "arrow",
  "chrono",
- "datafusion-common",
- "datafusion-expr",
- "datafusion-expr-common",
- "datafusion-physical-expr",
+ "datafusion-common 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-expr-common 53.1.0",
+ "datafusion-physical-expr 53.1.0",
+ "indexmap 2.14.0",
+ "itertools 0.14.0",
+ "log",
+ "regex",
+ "regex-syntax",
+]
+
+[[package]]
+name = "datafusion-optimizer"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77f20e8cf9e8654d92f4c16b24c487353ee5bf153ffc12d5772cd399ab8cd281"
+dependencies = [
+ "arrow",
+ "chrono",
+ "datafusion-common 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-expr-common 54.0.0",
+ "datafusion-physical-expr 54.0.0",
  "indexmap 2.14.0",
  "itertools 0.14.0",
  "log",
@@ -2532,11 +2918,11 @@ checksum = "4b1e68aba7a4b350401cfdf25a3d6f989ad898a7410164afe9ca52080244cb59"
 dependencies = [
  "ahash 0.8.12",
  "arrow",
- "datafusion-common",
- "datafusion-expr",
- "datafusion-expr-common",
- "datafusion-functions-aggregate-common",
- "datafusion-physical-expr-common",
+ "datafusion-common 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-expr-common 53.1.0",
+ "datafusion-functions-aggregate-common 53.1.0",
+ "datafusion-physical-expr-common 53.1.0",
  "half",
  "hashbrown 0.16.1",
  "indexmap 2.14.0",
@@ -2544,6 +2930,27 @@ dependencies = [
  "parking_lot",
  "paste",
  "petgraph",
+ "tokio",
+]
+
+[[package]]
+name = "datafusion-physical-expr"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f015a4a82f6f7ff7e1d8d4bf3870a936752fa38b17705dfcc14adef95aa8922c"
+dependencies = [
+ "arrow",
+ "datafusion-common 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-expr-common 54.0.0",
+ "datafusion-functions-aggregate-common 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
+ "half",
+ "hashbrown 0.17.1",
+ "indexmap 2.14.0",
+ "itertools 0.14.0",
+ "parking_lot",
+ "petgraph",
  "recursive",
  "tokio",
 ]
@@ -2555,11 +2962,26 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ea22315f33cf2e0adc104e8ec42e285f6ed93998d565c65e82fec6a9ee9f9db4"
 dependencies = [
  "arrow",
- "datafusion-common",
- "datafusion-expr",
- "datafusion-functions",
- "datafusion-physical-expr",
- "datafusion-physical-expr-common",
+ "datafusion-common 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-functions 53.1.0",
+ "datafusion-physical-expr 53.1.0",
+ "datafusion-physical-expr-common 53.1.0",
+ "itertools 0.14.0",
+]
+
+[[package]]
+name = "datafusion-physical-expr-adapter"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51e6ffff8acdfe54e0ea15ccf38115c4a9184433b0439f42907637928d00a235"
+dependencies = [
+ "arrow",
+ "datafusion-common 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-functions 54.0.0",
+ "datafusion-physical-expr 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
  "itertools 0.14.0",
 ]
 
@@ -2572,14 +2994,31 @@ dependencies = [
  "ahash 0.8.12",
  "arrow",
  "chrono",
- "datafusion-common",
- "datafusion-expr-common",
+ "datafusion-common 53.1.0",
+ "datafusion-expr-common 53.1.0",
  "hashbrown 0.16.1",
  "indexmap 2.14.0",
  "itertools 0.14.0",
  "parking_lot",
 ]
 
+[[package]]
+name = "datafusion-physical-expr-common"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7967a3e171c6a4bf09474b3f7a14f1a3db13ed1714ba12156f33fcce2bba54e8"
+dependencies = [
+ "arrow",
+ "chrono",
+ "datafusion-common 54.0.0",
+ "datafusion-expr-common 54.0.0",
+ "hashbrown 0.17.1",
+ "indexmap 2.14.0",
+ "itertools 0.14.0",
+ "parking_lot",
+ "pin-project",
+]
+
 [[package]]
 name = "datafusion-physical-optimizer"
 version = "53.1.0"
@@ -2587,14 +3026,32 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7cb13397809a425918f608dfe8653f332015a3e330004ab191b4404187238b95"
 dependencies = [
  "arrow",
- "datafusion-common",
- "datafusion-execution",
- "datafusion-expr",
- "datafusion-expr-common",
- "datafusion-physical-expr",
- "datafusion-physical-expr-common",
- "datafusion-physical-plan",
- "datafusion-pruning",
+ "datafusion-common 53.1.0",
+ "datafusion-execution 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-expr-common 53.1.0",
+ "datafusion-physical-expr 53.1.0",
+ "datafusion-physical-expr-common 53.1.0",
+ "datafusion-physical-plan 53.1.0",
+ "datafusion-pruning 53.1.0",
+ "itertools 0.14.0",
+]
+
+[[package]]
+name = "datafusion-physical-optimizer"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ff803e2a96054cb6d83f35f9e60fd4f42eac515e1932bd1b2dbc91d5fcbf36"
+dependencies = [
+ "arrow",
+ "datafusion-common 54.0.0",
+ "datafusion-execution 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-expr-common 54.0.0",
+ "datafusion-physical-expr 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
+ "datafusion-physical-plan 54.0.0",
+ "datafusion-pruning 54.0.0",
  "itertools 0.14.0",
  "recursive",
 ]
@@ -2610,15 +3067,15 @@ dependencies = [
  "arrow-ord",
  "arrow-schema",
  "async-trait",
- "datafusion-common",
- "datafusion-common-runtime",
- "datafusion-execution",
- "datafusion-expr",
- "datafusion-functions",
- "datafusion-functions-aggregate-common",
- "datafusion-functions-window-common",
- "datafusion-physical-expr",
- "datafusion-physical-expr-common",
+ "datafusion-common 53.1.0",
+ "datafusion-common-runtime 53.1.0",
+ "datafusion-execution 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-functions 53.1.0",
+ "datafusion-functions-aggregate-common 53.1.0",
+ "datafusion-functions-window-common 53.1.0",
+ "datafusion-physical-expr 53.1.0",
+ "datafusion-physical-expr-common 53.1.0",
  "futures",
  "half",
  "hashbrown 0.16.1",
@@ -2631,6 +3088,39 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "datafusion-physical-plan"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "776ee54d47d15bdb126452f9ca17b03761e3b004682914beaedd3f86eb507fbc"
+dependencies = [
+ "arrow",
+ "arrow-data",
+ "arrow-ipc",
+ "arrow-ord",
+ "arrow-schema",
+ "async-trait",
+ "datafusion-common 54.0.0",
+ "datafusion-common-runtime 54.0.0",
+ "datafusion-execution 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-functions 54.0.0",
+ "datafusion-functions-aggregate-common 54.0.0",
+ "datafusion-functions-window-common 54.0.0",
+ "datafusion-physical-expr 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
+ "futures",
+ "half",
+ "hashbrown 0.17.1",
+ "indexmap 2.14.0",
+ "itertools 0.14.0",
+ "log",
+ "num-traits",
+ "parking_lot",
+ "pin-project-lite",
+ "tokio",
+]
+
 [[package]]
 name = "datafusion-pruning"
 version = "53.1.0"
@@ -2638,16 +3128,32 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac8c76860e355616555081cab5968cec1af7a80701ff374510860bcd567e365a"
 dependencies = [
  "arrow",
- "datafusion-common",
- "datafusion-datasource",
- "datafusion-expr-common",
- "datafusion-physical-expr",
- "datafusion-physical-expr-common",
- "datafusion-physical-plan",
+ "datafusion-common 53.1.0",
+ "datafusion-datasource 53.1.0",
+ "datafusion-expr-common 53.1.0",
+ "datafusion-physical-expr 53.1.0",
+ "datafusion-physical-expr-common 53.1.0",
+ "datafusion-physical-plan 53.1.0",
  "itertools 0.14.0",
  "log",
 ]
 
+[[package]]
+name = "datafusion-pruning"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d5fb9e5774660aa69c3ba93c610f175f75b65cb8c3776edb3626de8f3a4f4ee3"
+dependencies = [
+ "arrow",
+ "datafusion-common 54.0.0",
+ "datafusion-datasource 54.0.0",
+ "datafusion-expr-common 54.0.0",
+ "datafusion-physical-expr 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
+ "datafusion-physical-plan 54.0.0",
+ "log",
+]
+
 [[package]]
 name = "datafusion-session"
 version = "53.1.0"
@@ -2655,37 +3161,54 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5412111aa48e2424ba926112e192f7a6b7e4ccb450145d25ce5ede9f19dc491e"
 dependencies = [
  "async-trait",
- "datafusion-common",
- "datafusion-execution",
- "datafusion-expr",
- "datafusion-physical-plan",
+ "datafusion-common 53.1.0",
+ "datafusion-execution 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-physical-plan 53.1.0",
+ "parking_lot",
+]
+
+[[package]]
+name = "datafusion-session"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15ce715fa2a61f4623cc234bcc14a3ef6a91f189128d5b14b468a6a17cdfc417"
+dependencies = [
+ "async-trait",
+ "datafusion-common 54.0.0",
+ "datafusion-execution 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-physical-plan 54.0.0",
  "parking_lot",
 ]
 
 [[package]]
 name = "datafusion-spark"
-version = "53.1.0"
+version = "54.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e059dcf8544da0d6598d0235be3cc29c209094a5976b2e4822e4a2cf91c2b5c5"
+checksum = "390bb0bf37cb2b95ffd65eacd66f60df50793d1f94097799e416f39477a51957"
 dependencies = [
  "arrow",
  "bigdecimal",
  "chrono",
  "crc32fast",
- "datafusion",
- "datafusion-catalog",
- "datafusion-common",
- "datafusion-execution",
- "datafusion-expr",
- "datafusion-functions",
- "datafusion-functions-aggregate",
- "datafusion-functions-nested",
+ "datafusion 54.0.0",
+ "datafusion-catalog 54.0.0",
+ "datafusion-common 54.0.0",
+ "datafusion-execution 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-functions 54.0.0",
+ "datafusion-functions-aggregate 54.0.0",
+ "datafusion-functions-aggregate-common 54.0.0",
+ "datafusion-functions-nested 54.0.0",
  "log",
+ "num-traits",
  "percent-encoding",
  "rand 0.9.4",
  "serde_json",
- "sha1 0.10.6",
- "sha2 0.10.9",
+ "sha1",
+ "sha2 0.11.0",
+ "twox-hash",
  "url",
 ]
 
@@ -2698,29 +3221,46 @@ dependencies = [
  "arrow",
  "bigdecimal",
  "chrono",
- "datafusion-common",
- "datafusion-expr",
- "datafusion-functions-nested",
+ "datafusion-common 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-functions-nested 53.1.0",
+ "indexmap 2.14.0",
+ "log",
+ "regex",
+ "sqlparser 0.61.0",
+]
+
+[[package]]
+name = "datafusion-sql"
+version = "54.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6094ad36a3ed6d7ac87b20b479b2d0b118250f66cf997603829fdc65b44a7099"
+dependencies = [
+ "arrow",
+ "bigdecimal",
+ "chrono",
+ "datafusion-common 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-functions-nested 54.0.0",
  "indexmap 2.14.0",
  "log",
  "recursive",
  "regex",
- "sqlparser",
+ "sqlparser 0.62.0",
 ]
 
 [[package]]
 name = "datafusion-sqllogictest"
-version = "53.1.0"
+version = "54.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04e5a4a7a49143a68936992b6dbb0db44121c635e9992b2482817278f1e69c56"
+checksum = "e0c08025966108056d3547d879c4d39e246277494f59ca12920f78187d95eea1"
 dependencies = [
  "arrow",
  "async-trait",
  "bigdecimal",
  "clap",
- "datafusion",
+ "datafusion 54.0.0",
  "datafusion-spark",
- "datafusion-substrait",
  "futures",
  "half",
  "indicatif",
@@ -2728,32 +3268,12 @@ dependencies = [
  "log",
  "object_store 0.13.2",
  "sqllogictest",
- "sqlparser",
+ "sqlparser 0.62.0",
  "tempfile",
  "thiserror 2.0.18",
  "tokio",
 ]
 
-[[package]]
-name = "datafusion-substrait"
-version = "53.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98494539a5468979cc42d86c7bc5f0f8cb71ee5c742694c26fc34efdd29dd2e5"
-dependencies = [
- "async-recursion",
- "async-trait",
- "chrono",
- "datafusion",
- "half",
- "itertools 0.14.0",
- "object_store 0.13.2",
- "pbjson-types",
- "prost 0.14.3",
- "substrait",
- "tokio",
- "url",
-]
-
 [[package]]
 name = "deepsize"
 version = "0.2.0"
@@ -2790,17 +3310,6 @@ dependencies = [
  "serde_core",
 ]
 
-[[package]]
-name = "derive_arbitrary"
-version = "1.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e567bd82dcff979e4b03460c307b3cdc9e96fde3d73bed1496d2bc75d9dd62a"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.117",
-]
-
 [[package]]
 name = "derive_more"
 version = "2.1.1"
@@ -2870,9 +3379,9 @@ dependencies = [
 
 [[package]]
 name = "displaydoc"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+checksum = "1ac70aa55017e108007fbaf5aa0f54b021c98f92ff8af59d42eda9da96e3dd4f"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2905,25 +3414,6 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab23e69df104e2fd85ee63a533a22d2132ef5975dc6b36f9f3e5a7305e4a8ed7"
 
-[[package]]
-name = "duckdb"
-version = "1.10502.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fdc796383b176dd5a45353fbb5e64583c0ee4da12cb62c9e510b785324b2488"
-dependencies = [
- "arrow",
- "cast",
- "comfy-table",
- "fallible-iterator",
- "fallible-streaming-iterator",
- "hashlink",
- "libduckdb-sys",
- "num",
- "num-integer",
- "rust_decimal",
- "strum 0.27.2",
-]
-
 [[package]]
 name = "duckdb-bench"
 version = "0.1.0"
@@ -3125,32 +3615,27 @@ dependencies = [
  "ext-trait",
 ]
 
-[[package]]
-name = "fallible-iterator"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
-
-[[package]]
-name = "fallible-streaming-iterator"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
-
 [[package]]
 name = "fast-float2"
 version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8eb564c5c7423d25c886fb561d1e4ee69f72354d16918afa32c08811f6b6a55"
 
+[[package]]
+name = "fast-srgb8"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd2e7510819d6fbf51a5545c8f922716ecfb14df168a3242f7d33e0239efe6a1"
+
 [[package]]
 name = "fastlanes"
-version = "0.5.0"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "414cb755aee48ff7b0907995d2949c68c8c17900970076dff6a808e18e592d71"
+checksum = "20c597e23b8ec8506f589d18bc701ca83a3def6086748f628ad23092e1dfe577"
 dependencies = [
  "arrayref",
  "const_for",
+ "core_detect",
  "num-traits",
  "paste",
  "seq-macro",
@@ -3272,9 +3757,9 @@ dependencies = [
 
 [[package]]
 name = "fsst-rs"
-version = "0.5.10"
+version = "0.5.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3bf53d7c403a2b76873d4d66ba7d79c54bde2784cdaba6083f223d6e33270708"
+checksum = "9b13ac798afc0d9194eb4efefef8b9332efbd80b43f302a968cb8cb23b9d5360"
 dependencies = [
  "rustc-hash",
 ]
@@ -3412,9 +3897,9 @@ dependencies = [
 
 [[package]]
 name = "generator"
-version = "0.8.8"
+version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52f04ae4152da20c76fe800fa48659201d5cf627c5149ca0b707b69d7eef6cf9"
+checksum = "b3b854b0e584ead1a33f18b2fcad7cf7be18b3875c78816b753639aa501513ae"
 dependencies = [
  "cc",
  "cfg-if",
@@ -3435,6 +3920,65 @@ dependencies = [
  "version_check",
 ]
 
+[[package]]
+name = "geo-traits"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e7c353d12a704ccfab1ba8bfb1a7fe6cb18b665bf89d37f4f7890edcd260206"
+dependencies = [
+ "geo-types",
+]
+
+[[package]]
+name = "geo-types"
+version = "0.7.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94776032c45f950d30a13af6113c2ad5625316c9abfbccee4dd5a6695f8fe0f5"
+dependencies = [
+ "approx",
+ "num-traits",
+ "serde",
+]
+
+[[package]]
+name = "geoarrow"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec42ac7fb4fdcd6982dab92d24faf436f18c36e47c3f813a33619a2728718a30"
+dependencies = [
+ "geoarrow-array",
+ "geoarrow-schema",
+]
+
+[[package]]
+name = "geoarrow-array"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dafe7b7de3fab1a8b7099fd6a6434ca955fa65065f9c19f0f8a133693f3c2b0e"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-schema",
+ "geo-traits",
+ "geoarrow-schema",
+ "num-traits",
+ "wkb",
+ "wkt",
+]
+
+[[package]]
+name = "geoarrow-schema"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d4a7edb2a1d87024a93805332a9c8184a0354836271d42c0d18cf628a5e3cd0"
+dependencies = [
+ "arrow-schema",
+ "geo-traits",
+ "serde",
+ "serde_json",
+ "thiserror 1.0.69",
+]
+
 [[package]]
 name = "get_dir"
 version = "0.5.0"
@@ -3607,15 +4151,6 @@ dependencies = [
  "foldhash 0.2.0",
 ]
 
-[[package]]
-name = "hashlink"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7382cf6263419f2d8df38c55d7da83da5c18aef87fc7a7fc1fb1e344edfe14c1"
-dependencies = [
- "hashbrown 0.15.5",
-]
-
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -3645,9 +4180,9 @@ dependencies = [
 
 [[package]]
 name = "http"
-version = "1.4.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
+checksum = "8be7462df143984c4598a256ef469b251d7d7f9e271135073e78fc535414f3d0"
 dependencies = [
  "bytes",
  "itoa",
@@ -3682,12 +4217,6 @@ version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
 
-[[package]]
-name = "httpdate"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
-
 [[package]]
 name = "humansize"
 version = "2.1.3"
@@ -3714,9 +4243,9 @@ dependencies = [
 
 [[package]]
 name = "hyper"
-version = "1.9.0"
+version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6299f016b246a94207e63da54dbe807655bf9e00044f73ded42c3ac5305fbcca"
+checksum = "55281c53a1894c864990125767da440a4e630446785086f52523b20033b74498"
 dependencies = [
  "atomic-waker",
  "bytes",
@@ -3726,7 +4255,6 @@ dependencies = [
  "http",
  "http-body",
  "httparse",
- "httpdate",
  "itoa",
  "pin-project-lite",
  "smallvec",
@@ -3748,7 +4276,6 @@ dependencies = [
  "tokio",
  "tokio-rustls",
  "tower-service",
- "webpki-roots",
 ]
 
 [[package]]
@@ -4007,7 +4534,6 @@ checksum = "7b4a6248eb93a4401ed2f37dfe8ea592d3cf05b7cf4f8efa867b6895af7e094e"
 dependencies = [
  "console 0.16.3",
  "once_cell",
- "regex",
  "similar 2.7.0",
  "tempfile",
 ]
@@ -4319,11 +4845,11 @@ dependencies = [
  "chrono",
  "crossbeam-skiplist",
  "dashmap",
- "datafusion",
- "datafusion-expr",
- "datafusion-functions",
- "datafusion-physical-expr",
- "datafusion-physical-plan",
+ "datafusion 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-functions 53.1.0",
+ "datafusion-physical-expr 53.1.0",
+ "datafusion-physical-plan 53.1.0",
  "deepsize",
  "either",
  "futures",
@@ -4346,7 +4872,7 @@ dependencies = [
  "object_store 0.12.5",
  "permutation",
  "pin-project",
- "prost 0.14.3",
+ "prost 0.14.4",
  "prost-build",
  "prost-types",
  "rand 0.9.4",
@@ -4428,8 +4954,8 @@ dependencies = [
  "byteorder",
  "bytes",
  "chrono",
- "datafusion-common",
- "datafusion-sql",
+ "datafusion-common 53.1.0",
+ "datafusion-sql 53.1.0",
  "deepsize",
  "futures",
  "itertools 0.13.0",
@@ -4441,7 +4967,7 @@ dependencies = [
  "num_cpus",
  "object_store 0.12.5",
  "pin-project",
- "prost 0.14.3",
+ "prost 0.14.4",
  "rand 0.9.4",
  "roaring",
  "serde_json",
@@ -4469,10 +4995,10 @@ dependencies = [
  "arrow-select",
  "async-trait",
  "chrono",
- "datafusion",
- "datafusion-common",
- "datafusion-functions",
- "datafusion-physical-expr",
+ "datafusion 53.1.0",
+ "datafusion-common 53.1.0",
+ "datafusion-functions 53.1.0",
+ "datafusion-physical-expr 53.1.0",
  "futures",
  "jsonb",
  "lance-arrow",
@@ -4480,7 +5006,7 @@ dependencies = [
  "lance-datagen",
  "log",
  "pin-project",
- "prost 0.14.3",
+ "prost 0.14.4",
  "prost-build",
  "snafu",
  "tokio",
@@ -4534,7 +5060,7 @@ dependencies = [
  "log",
  "lz4",
  "num-traits",
- "prost 0.14.3",
+ "prost 0.14.4",
  "prost-build",
  "prost-types",
  "rand 0.9.4",
@@ -4562,7 +5088,7 @@ dependencies = [
  "async-trait",
  "byteorder",
  "bytes",
- "datafusion-common",
+ "datafusion-common 53.1.0",
  "deepsize",
  "futures",
  "lance-arrow",
@@ -4572,7 +5098,7 @@ dependencies = [
  "log",
  "num-traits",
  "object_store 0.12.5",
- "prost 0.14.3",
+ "prost 0.14.4",
  "prost-build",
  "prost-types",
  "snafu",
@@ -4600,11 +5126,11 @@ dependencies = [
  "bytes",
  "chrono",
  "crossbeam-queue",
- "datafusion",
- "datafusion-common",
- "datafusion-expr",
- "datafusion-physical-expr",
- "datafusion-sql",
+ "datafusion 53.1.0",
+ "datafusion-common 53.1.0",
+ "datafusion-expr 53.1.0",
+ "datafusion-physical-expr 53.1.0",
+ "datafusion-sql 53.1.0",
  "deepsize",
  "dirs",
  "fst",
@@ -4627,7 +5153,7 @@ dependencies = [
  "ndarray",
  "num-traits",
  "object_store 0.12.5",
- "prost 0.14.3",
+ "prost 0.14.4",
  "prost-build",
  "prost-types",
  "rand 0.9.4",
@@ -4678,7 +5204,7 @@ dependencies = [
  "object_store 0.12.5",
  "path_abs",
  "pin-project",
- "prost 0.14.3",
+ "prost 0.14.4",
  "rand 0.9.4",
  "serde",
  "snafu",
@@ -4758,7 +5284,7 @@ dependencies = [
  "lance-io",
  "log",
  "object_store 0.12.5",
- "prost 0.14.3",
+ "prost 0.14.4",
  "prost-build",
  "prost-types",
  "rand 0.9.4",
@@ -4901,28 +5427,11 @@ version = "0.2.186"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
 
-[[package]]
-name = "libduckdb-sys"
-version = "1.10502.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d7401630ae2abcff642f7156294289e50f2d222e061c026ad797b01bf20c215"
-dependencies = [
- "cc",
- "flate2",
- "pkg-config",
- "reqwest 0.12.28",
- "serde",
- "serde_json",
- "tar",
- "vcpkg",
- "zip 6.0.0",
-]
-
 [[package]]
 name = "libfuzzer-sys"
-version = "0.4.12"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f12a681b7dd8ce12bff52488013ba614b869148d54dd79836ab85aafdd53f08d"
+checksum = "a9fd2f41a1cba099f79a0b6b6c35656cf7c03351a7bae8ff0f28f25270f929d2"
 dependencies = [
  "arbitrary",
  "cc",
@@ -4985,9 +5494,9 @@ dependencies = [
 
 [[package]]
 name = "libredox"
-version = "0.1.16"
+version = "0.1.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e02f3bb43d335493c96bf3fd3a321600bf6bd07ed34bc64118e9293bdffea46c"
+checksum = "f02ab6bace2054fb888a3c16f990117b579d14a3088e472d63c6011fa185c9d3"
 dependencies = [
  "libc",
 ]
@@ -5022,12 +5531,6 @@ dependencies = [
  "cc",
 ]
 
-[[package]]
-name = "linux-raw-sys"
-version = "0.4.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
-
 [[package]]
 name = "linux-raw-sys"
 version = "0.12.1"
@@ -5057,9 +5560,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.30"
+version = "0.4.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "616ec5685824bcc94416c6d4a7a446eea774a31efd7062c8480ba6fd06d7a6e5"
+checksum = "953f07c43838f8e6f9758cab68bf5bed85465e7587ebe0b823f1bcd81978ad3a"
 
 [[package]]
 name = "loom"
@@ -5076,11 +5579,11 @@ dependencies = [
 
 [[package]]
 name = "lru"
-version = "0.16.4"
+version = "0.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f66e8d5d03f609abc3a39e6f08e4164ebf1447a732906d39eb9b99b7919ef39"
+checksum = "8a860605968fce16869fd239cf4237a82f3ac470723415db603b0e8b6c8d4fb9"
 dependencies = [
- "hashbrown 0.16.1",
+ "hashbrown 0.17.1",
 ]
 
 [[package]]
@@ -5119,9 +5622,9 @@ dependencies = [
 
 [[package]]
 name = "lzma-rust2"
-version = "0.16.3"
+version = "0.16.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e9ceaec84b54518262de7cf06b8b43e83c808349960f1610b21b0bfc9640f20"
+checksum = "ce716bf1a316f47a280fc76295f6495b5bea4752bca01c3b3885e101b1c23c02"
 dependencies = [
  "sha2 0.11.0",
 ]
@@ -5151,12 +5654,6 @@ dependencies = [
  "regex-automata",
 ]
 
-[[package]]
-name = "matchit"
-version = "0.8.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"
-
 [[package]]
 name = "matrixmultiply"
 version = "0.3.10"
@@ -5171,37 +5668,23 @@ dependencies = [
 ]
 
 [[package]]
-name = "maud"
-version = "0.27.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8156733e27020ea5c684db5beac5d1d611e1272ab17901a49466294b84fc217e"
-dependencies = [
- "axum-core",
- "http",
- "itoa",
- "maud_macros",
-]
-
-[[package]]
-name = "maud_macros"
-version = "0.27.0"
+name = "md-5"
+version = "0.10.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7261b00f3952f617899bc012e3dbd56e4f0110a038175929fa5d18e5a19913ca"
+checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
 dependencies = [
- "proc-macro2",
- "proc-macro2-diagnostics",
- "quote",
- "syn 2.0.117",
+ "cfg-if",
+ "digest 0.10.7",
 ]
 
 [[package]]
 name = "md-5"
-version = "0.10.6"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
+checksum = "69b6441f590336821bb897fb28fc622898ccceb1d6cea3fde5ea86b090c4de98"
 dependencies = [
  "cfg-if",
- "digest 0.10.7",
+ "digest 0.11.3",
 ]
 
 [[package]]
@@ -5262,9 +5745,9 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "1.2.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1"
+checksum = "02bd0af71c67b473010cbbc60715ee815645a4dc942899111f494b4b737d6fda"
 dependencies = [
  "libc",
  "log",
@@ -5304,28 +5787,6 @@ version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d87ecb2933e8aeadb3e3a02b828fed80a7528047e68b4f424523a0981a3a084"
 
-[[package]]
-name = "multiversion"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7edb7f0ff51249dfda9ab96b5823695e15a052dc15074c9dbf3d118afaf2c201"
-dependencies = [
- "multiversion-macros",
- "target-features",
-]
-
-[[package]]
-name = "multiversion-macros"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b093064383341eb3271f42e381cb8f10a01459478446953953c75d24bd339fc0"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.117",
- "target-features",
-]
-
 [[package]]
 name = "ndarray"
 version = "0.16.1"
@@ -5489,20 +5950,6 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
-[[package]]
-name = "num"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23"
-dependencies = [
- "num-bigint",
- "num-complex",
- "num-integer",
- "num-iter",
- "num-rational",
- "num-traits",
-]
-
 [[package]]
 name = "num-bigint"
 version = "0.4.6"
@@ -5511,7 +5958,6 @@ checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
 dependencies = [
  "num-integer",
  "num-traits",
- "serde",
 ]
 
 [[package]]
@@ -5538,28 +5984,6 @@ dependencies = [
  "num-traits",
 ]
 
-[[package]]
-name = "num-iter"
-version = "0.1.45"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf"
-dependencies = [
- "autocfg",
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "num-rational"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
-dependencies = [
- "num-bigint",
- "num-integer",
- "num-traits",
-]
-
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -5596,6 +6020,7 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8"
 dependencies = [
+ "proc-macro-crate",
  "proc-macro2",
  "quote",
  "syn 2.0.117",
@@ -5682,7 +6107,7 @@ dependencies = [
  "humantime",
  "hyper",
  "itertools 0.14.0",
- "md-5",
+ "md-5 0.10.6",
  "parking_lot",
  "percent-encoding",
  "quick-xml",
@@ -5783,7 +6208,7 @@ dependencies = [
  "opentelemetry-http",
  "opentelemetry-proto",
  "opentelemetry_sdk",
- "prost 0.14.3",
+ "prost 0.14.4",
  "reqwest 0.13.4",
  "thiserror 2.0.18",
 ]
@@ -5796,7 +6221,7 @@ checksum = "56d658ba1faf63f7b9c492cfbe6e0ec365440a16132d3270c1065f7b33f1b638"
 dependencies = [
  "opentelemetry",
  "opentelemetry_sdk",
- "prost 0.14.3",
+ "prost 0.14.4",
 ]
 
 [[package]]
@@ -5845,11 +6270,35 @@ version = "4.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d211803b9b6b570f68772237e415a029d5a50c65d382910b879fb19d3271f94d"
 
+[[package]]
+name = "palette"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cbf71184cc5ecc2e4e1baccdb21026c20e5fc3dcf63028a086131b3ab00b6e6"
+dependencies = [
+ "approx",
+ "fast-srgb8",
+ "libm",
+ "palette_derive",
+]
+
+[[package]]
+name = "palette_derive"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5030daf005bface118c096f510ffb781fc28f9ab6a32ab224d8631be6851d30"
+dependencies = [
+ "by_address",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "papergrid"
-version = "0.17.0"
+version = "0.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6978128c8b51d8f4080631ceb2302ab51e32cc6e8615f735ee2f83fd269ae3f1"
+checksum = "d0984e668274d34691bc2b262ef0d115de5fa9973bcdee7ae32213f93099153e"
 dependencies = [
  "bytecount",
  "fnv",
@@ -6014,43 +6463,6 @@ dependencies = [
  "stfu8",
 ]
 
-[[package]]
-name = "pbjson"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "898bac3fa00d0ba57a4e8289837e965baa2dee8c3749f3b11d45a64b4223d9c3"
-dependencies = [
- "base64",
- "serde",
-]
-
-[[package]]
-name = "pbjson-build"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af22d08a625a2213a78dbb0ffa253318c5c79ce3133d32d296655a7bdfb02095"
-dependencies = [
- "heck",
- "itertools 0.14.0",
- "prost 0.14.3",
- "prost-types",
-]
-
-[[package]]
-name = "pbjson-types"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e748e28374f10a330ee3bb9f29b828c0ac79831a32bab65015ad9b661ead526"
-dependencies = [
- "bytes",
- "chrono",
- "pbjson",
- "pbjson-build",
- "prost 0.14.3",
- "prost-build",
- "serde",
-]
-
 [[package]]
 name = "pbkdf2"
 version = "0.13.0"
@@ -6207,7 +6619,7 @@ dependencies = [
  "concurrent-queue",
  "hermit-abi",
  "pin-project-lite",
- "rustix 1.1.4",
+ "rustix",
  "windows-sys 0.61.2",
 ]
 
@@ -6323,18 +6735,6 @@ dependencies = [
  "unicode-ident",
 ]
 
-[[package]]
-name = "proc-macro2-diagnostics"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.117",
- "version_check",
-]
-
 [[package]]
 name = "prost"
 version = "0.12.6"
@@ -6347,19 +6747,19 @@ dependencies = [
 
 [[package]]
 name = "prost"
-version = "0.14.3"
+version = "0.14.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2ea70524a2f82d518bce41317d0fae74151505651af45faf1ffbd6fd33f0568"
+checksum = "528ac67416ff8646872a3c02cad9cc4ee5dc9f9540c9b10771855c95cb2e5ae1"
 dependencies = [
  "bytes",
- "prost-derive 0.14.3",
+ "prost-derive 0.14.4",
 ]
 
 [[package]]
 name = "prost-build"
-version = "0.14.3"
+version = "0.14.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "343d3bd7056eda839b03204e68deff7d1b13aba7af2b2fd16890697274262ee7"
+checksum = "03da047801ff44bb6a4d407d4860c05fd70bb81714e6b2f3812603d5b145b042"
 dependencies = [
  "heck",
  "itertools 0.14.0",
@@ -6367,7 +6767,7 @@ dependencies = [
  "multimap",
  "petgraph",
  "prettyplease",
- "prost 0.14.3",
+ "prost 0.14.4",
  "prost-types",
  "regex",
  "syn 2.0.117",
@@ -6389,9 +6789,9 @@ dependencies = [
 
 [[package]]
 name = "prost-derive"
-version = "0.14.3"
+version = "0.14.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27c6023962132f4b30eb4c172c91ce92d933da334c59c23cddee82358ddafb0b"
+checksum = "b570b25f7617e43d59005d0990ccb79e950a423952cea19671b7a876da390adf"
 dependencies = [
  "anyhow",
  "itertools 0.14.0",
@@ -6402,11 +6802,11 @@ dependencies = [
 
 [[package]]
 name = "prost-types"
-version = "0.14.3"
+version = "0.14.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8991c4cbdb8bc5b11f0b074ffe286c30e523de90fee5ba8132f1399f23cb3dd7"
+checksum = "f94967dc7688f3054c7fac87473ffae4cc4c3904800e2d9f5b857246d8963b0a"
 dependencies = [
- "prost 0.14.3",
+ "prost 0.14.4",
 ]
 
 [[package]]
@@ -6557,12 +6957,6 @@ dependencies = [
  "url",
 ]
 
-[[package]]
-name = "quad-rand"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a651516ddc9168ebd67b24afd085a718be02f8858fe406591b013d101ce2f40"
-
 [[package]]
 name = "quick-xml"
 version = "0.39.4"
@@ -6626,7 +7020,7 @@ dependencies = [
  "once_cell",
  "socket2",
  "tracing",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -6806,30 +7200,34 @@ checksum = "973443cf09a9c8656b574a866ab68dfa19f0867d0340648c7d2f6a71b8a8ea68"
 
 [[package]]
 name = "ratatui"
-version = "0.30.0"
+version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1ce67fb8ba4446454d1c8dbaeda0557ff5e94d39d5e5ed7f10a65eb4c8266bc"
+checksum = "1695748e3a735b34968c887ceea5a380b43545903868ae8f5b666593100f6b68"
 dependencies = [
  "instability",
  "ratatui-core",
  "ratatui-crossterm",
  "ratatui-widgets",
+ "serde",
 ]
 
 [[package]]
 name = "ratatui-core"
-version = "0.1.0"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ef8dea09a92caaf73bff7adb70b76162e5937524058a7e5bff37869cbbec293"
+checksum = "42d3603f354bba8c595fa47860e60142d7372b7210c27044c6a7d0e1a4336b44"
 dependencies = [
  "bitflags",
  "compact_str",
- "hashbrown 0.16.1",
+ "critical-section",
+ "hashbrown 0.17.1",
  "indoc",
  "itertools 0.14.0",
  "kasuari",
  "lru",
- "strum 0.27.2",
+ "palette",
+ "serde",
+ "strum 0.28.0",
  "thiserror 2.0.18",
  "unicode-segmentation",
  "unicode-truncate",
@@ -6838,30 +7236,31 @@ dependencies = [
 
 [[package]]
 name = "ratatui-crossterm"
-version = "0.1.0"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "577c9b9f652b4c121fb25c6a391dd06406d3b092ba68827e6d2f09550edc54b3"
+checksum = "2b2867bedcbd6a690ca4f8672a687b730ec07660c79844517b084311b529980c"
 dependencies = [
  "cfg-if",
- "crossterm 0.29.0",
+ "crossterm",
  "instability",
  "ratatui-core",
 ]
 
 [[package]]
 name = "ratatui-widgets"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7dbfa023cd4e604c2553483820c5fe8aa9d71a42eea5aa77c6e7f35756612db"
+checksum = "7ef4f17dd7ac3abf5adc2b920a03c61eee4bfe6a88fa5191936895525371d79c"
 dependencies = [
  "bitflags",
- "hashbrown 0.16.1",
+ "hashbrown 0.17.1",
  "indoc",
  "instability",
  "itertools 0.14.0",
  "line-clipping",
  "ratatui-core",
- "strum 0.27.2",
+ "serde",
+ "strum 0.28.0",
  "time",
  "unicode-segmentation",
  "unicode-width 0.2.2",
@@ -7004,16 +7403,6 @@ version = "0.8.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
 
-[[package]]
-name = "regress"
-version = "0.10.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2057b2325e68a893284d1538021ab90279adac1139957ca2a74426c6f118fb48"
-dependencies = [
- "hashbrown 0.16.1",
- "memchr",
-]
-
 [[package]]
 name = "relative-path"
 version = "1.9.3"
@@ -7038,7 +7427,6 @@ dependencies = [
  "base64",
  "bytes",
  "encoding_rs",
- "futures-channel",
  "futures-core",
  "futures-util",
  "h2",
@@ -7073,7 +7461,6 @@ dependencies = [
  "wasm-bindgen-futures",
  "wasm-streams 0.4.2",
  "web-sys",
- "webpki-roots",
 ]
 
 [[package]]
@@ -7104,8 +7491,6 @@ dependencies = [
  "rustls",
  "rustls-pki-types",
  "rustls-platform-verifier",
- "serde",
- "serde_json",
  "sync_wrapper",
  "tokio",
  "tokio-rustls",
@@ -7261,19 +7646,6 @@ dependencies = [
  "semver",
 ]
 
-[[package]]
-name = "rustix"
-version = "0.38.44"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
-dependencies = [
- "bitflags",
- "errno",
- "libc",
- "linux-raw-sys 0.4.15",
- "windows-sys 0.59.0",
-]
-
 [[package]]
 name = "rustix"
 version = "1.1.4"
@@ -7283,7 +7655,7 @@ dependencies = [
  "bitflags",
  "errno",
  "libc",
- "linux-raw-sys 0.12.1",
+ "linux-raw-sys",
  "windows-sys 0.61.2",
 ]
 
@@ -7304,9 +7676,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-native-certs"
-version = "0.8.3"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63"
+checksum = "dab5152771c58876a2146916e53e35057e1a4dfa2b9df0f0305b07f611fdea4d"
 dependencies = [
  "openssl-probe",
  "rustls-pki-types",
@@ -7393,18 +7765,6 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
-[[package]]
-name = "schemars"
-version = "0.8.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fbf2ae1b8bc8e02df939598064d22402220cd5bbcca1c76f7d6a310974d5615"
-dependencies = [
- "dyn-clone",
- "schemars_derive",
- "serde",
- "serde_json",
-]
-
 [[package]]
 name = "schemars"
 version = "0.9.0"
@@ -7429,18 +7789,6 @@ dependencies = [
  "serde_json",
 ]
 
-[[package]]
-name = "schemars_derive"
-version = "0.8.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32e265784ad618884abaea0600a9adf15393368d840e0222d101a072f3f7534d"
-dependencies = [
- "proc-macro2",
- "quote",
- "serde_derive_internals",
- "syn 2.0.117",
-]
-
 [[package]]
 name = "scoped-tls"
 version = "1.0.1"
@@ -7514,16 +7862,6 @@ dependencies = [
  "serde_derive",
 ]
 
-[[package]]
-name = "serde_bytes"
-version = "0.11.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5d440709e79d88e51ac01c4b72fc6cb7314017bb7da9eeff678aa94c10e3ea8"
-dependencies = [
- "serde",
- "serde_core",
-]
-
 [[package]]
 name = "serde_core"
 version = "1.0.228"
@@ -7544,17 +7882,6 @@ dependencies = [
  "syn 2.0.117",
 ]
 
-[[package]]
-name = "serde_derive_internals"
-version = "0.29.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.117",
-]
-
 [[package]]
 name = "serde_json"
 version = "1.0.150"
@@ -7568,17 +7895,6 @@ dependencies = [
  "zmij",
 ]
 
-[[package]]
-name = "serde_path_to_error"
-version = "0.1.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10a9ff822e371bb5403e391ecd83e182e0e77ba7f6fe0160b795797109d1b457"
-dependencies = [
- "itoa",
- "serde",
- "serde_core",
-]
-
 [[package]]
 name = "serde_repr"
 version = "0.1.20"
@@ -7608,18 +7924,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "serde_tokenstream"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7c49585c52c01f13c5c2ebb333f14f6885d76daa768d8a037d28017ec538c69"
-dependencies = [
- "proc-macro2",
- "quote",
- "serde",
- "syn 2.0.117",
-]
-
 [[package]]
 name = "serde_urlencoded"
 version = "0.7.1"
@@ -7634,9 +7938,9 @@ dependencies = [
 
 [[package]]
 name = "serde_with"
-version = "3.20.0"
+version = "3.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e72c1c2cb7b223fafb600a619537a871c2818583d619401b785e7c0b746ccde2"
+checksum = "76a5c54c7310e7b8b9577c286d7e399ddd876c3e12b3ed917a8aabc4b96e9e8c"
 dependencies = [
  "base64",
  "bs58",
@@ -7654,9 +7958,9 @@ dependencies = [
 
 [[package]]
 name = "serde_with_macros"
-version = "3.20.0"
+version = "3.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b90c488738ecb4fb0262f41f43bc40efc5868d9fb744319ddf5f5317f417bfac"
+checksum = "84d57bc0c8b9a17920c178daa6bb924850d54a9c97ab45194bb8c17ad66bb660"
 dependencies = [
  "darling",
  "proc-macro2",
@@ -7664,19 +7968,6 @@ dependencies = [
  "syn 2.0.117",
 ]
 
-[[package]]
-name = "serde_yaml"
-version = "0.9.34+deprecated"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
-dependencies = [
- "indexmap 2.14.0",
- "itoa",
- "ryu",
- "serde",
- "unsafe-libyaml",
-]
-
 [[package]]
 name = "serial_test"
 version = "3.5.0"
@@ -7702,17 +7993,6 @@ dependencies = [
  "syn 2.0.117",
 ]
 
-[[package]]
-name = "sha1"
-version = "0.10.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
-dependencies = [
- "cfg-if",
- "cpufeatures 0.2.17",
- "digest 0.10.7",
-]
-
 [[package]]
 name = "sha1"
 version = "0.11.0"
@@ -7901,18 +8181,18 @@ dependencies = [
 
 [[package]]
 name = "snafu"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1d4bced6a69f90b2056c03dcff2c4737f98d6fb9e0853493996e1d253ca29c6"
+checksum = "d1a012328be2e3f5d5f6f3218147ca02588cea4cb865e876849ab6debcf36522"
 dependencies = [
  "snafu-derive",
 ]
 
 [[package]]
 name = "snafu-derive"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54254b8531cafa275c5e096f62d48c81435d1015405a91198ddb11e967301d40"
+checksum = "5f103c50866b8743da9429b8a581d81a27c2d3a9c4ac7df8f8571c1dd7896eda"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -7928,9 +8208,9 @@ checksum = "1b6b67fb9a61334225b5b790716f609cd58395f895b3fe8b328786812a40bc3b"
 
 [[package]]
 name = "socket2"
-version = "0.6.3"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
+checksum = "52d1cfed4120b4d927bf7c0f86d2087a4a7d6027c906d9f9d525a80573b9be51"
 dependencies = [
  "libc",
  "windows-sys 0.61.2",
@@ -7950,7 +8230,7 @@ dependencies = [
  "humantime",
  "itertools 0.13.0",
  "libtest-mimic",
- "md-5",
+ "md-5 0.10.6",
  "owo-colors",
  "rand 0.8.6",
  "regex",
@@ -7966,6 +8246,16 @@ name = "sqlparser"
 version = "0.61.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dbf5ea8d4d7c808e1af1cbabebca9a2abe603bcefc22294c5b95018d53200cb7"
+dependencies = [
+ "log",
+ "sqlparser_derive",
+]
+
+[[package]]
+name = "sqlparser"
+version = "0.62.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c6d1b651dc4edf07eead2a0c6c78016ce971bc2c10da5266861b13f25e7cec"
 dependencies = [
  "log",
  "recursive",
@@ -8045,15 +8335,6 @@ dependencies = [
  "strum_macros 0.26.4",
 ]
 
-[[package]]
-name = "strum"
-version = "0.27.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
-dependencies = [
- "strum_macros 0.27.2",
-]
-
 [[package]]
 name = "strum"
 version = "0.28.0"
@@ -8076,18 +8357,6 @@ dependencies = [
  "syn 2.0.117",
 ]
 
-[[package]]
-name = "strum_macros"
-version = "0.27.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "syn 2.0.117",
-]
-
 [[package]]
 name = "strum_macros"
 version = "0.28.0"
@@ -8110,31 +8379,6 @@ dependencies = [
  "unicode-width 0.1.14",
 ]
 
-[[package]]
-name = "substrait"
-version = "0.62.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62fc4b483a129b9772ccb9c3f7945a472112fdd9140da87f8a4e7f1d44e045d0"
-dependencies = [
- "heck",
- "pbjson",
- "pbjson-build",
- "pbjson-types",
- "prettyplease",
- "prost 0.14.3",
- "prost-build",
- "prost-types",
- "regress",
- "schemars 0.8.22",
- "semver",
- "serde",
- "serde_json",
- "serde_yaml",
- "syn 2.0.117",
- "typify",
- "walkdir",
-]
-
 [[package]]
 name = "subtle"
 version = "2.6.1"
@@ -8220,9 +8464,9 @@ dependencies = [
 
 [[package]]
 name = "tabled"
-version = "0.20.0"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e39a2ee1fbcd360805a771e1b300f78cc88fec7b8d3e2f71cd37bbf23e725c7d"
+checksum = "b5dc662e6da844ad6e428ad16b57967c9d33c82e16bb1c258326c0c078605dff"
 dependencies = [
  "papergrid",
  "testing_table",
@@ -8269,12 +8513,6 @@ dependencies = [
  "xattr",
 ]
 
-[[package]]
-name = "target-features"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1bbb9f3c5c463a01705937a24fdabc5047929ac764b2d5b9cf681c1f5041ed5"
-
 [[package]]
 name = "target-lexicon"
 version = "0.13.5"
@@ -8299,7 +8537,7 @@ dependencies = [
  "fastrand",
  "getrandom 0.4.2",
  "once_cell",
- "rustix 1.1.4",
+ "rustix",
  "windows-sys 0.61.2",
 ]
 
@@ -8318,7 +8556,7 @@ version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "230a1b821ccbd75b185820a1f1ff7b14d21da1e442e22c0863ea5f08771a8874"
 dependencies = [
- "rustix 1.1.4",
+ "rustix",
  "windows-sys 0.61.2",
 ]
 
@@ -8630,9 +8868,9 @@ dependencies = [
 
 [[package]]
 name = "toml_edit"
-version = "0.25.11+spec-1.1.0"
+version = "0.25.12+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b59c4d22ed448339746c59b905d24568fcbb3ab65a500494f7b8c3e97739f2b"
+checksum = "d2153edc6955a6c354fad8f5efd38b6a8769bdccf9fe50f8e1329f81b0baa5d7"
 dependencies = [
  "indexmap 2.14.0",
  "toml_datetime 1.1.1+spec-1.1.0",
@@ -8668,7 +8906,6 @@ dependencies = [
  "tokio",
  "tower-layer",
  "tower-service",
- "tracing",
 ]
 
 [[package]]
@@ -8691,7 +8928,6 @@ dependencies = [
  "tower",
  "tower-layer",
  "tower-service",
- "tracing",
  "url",
 ]
 
@@ -8829,62 +9065,15 @@ dependencies = [
 
 [[package]]
 name = "typed-path"
-version = "0.12.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e28f89b80c87b8fb0cf04ab448d5dd0dd0ade2f8891bae878de66a75a28600e"
-
-[[package]]
-name = "typenum"
-version = "1.20.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40ce102ab67701b8526c123c1bab5cbe42d7040ccfd0f64af1a385808d2f43de"
-
-[[package]]
-name = "typify"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6d5bcc6f62eb1fa8aa4098f39b29f93dcb914e17158b76c50360911257aa629"
-dependencies = [
- "typify-impl",
- "typify-macro",
-]
-
-[[package]]
-name = "typify-impl"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1eb359f7ffa4f9ebe947fa11a1b2da054564502968db5f317b7e37693cb2240"
-dependencies = [
- "heck",
- "log",
- "proc-macro2",
- "quote",
- "regress",
- "schemars 0.8.22",
- "semver",
- "serde",
- "serde_json",
- "syn 2.0.117",
- "thiserror 2.0.18",
- "unicode-ident",
-]
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e28f89b80c87b8fb0cf04ab448d5dd0dd0ade2f8891bae878de66a75a28600e"
 
 [[package]]
-name = "typify-macro"
-version = "0.5.0"
+name = "typenum"
+version = "1.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "911c32f3c8514b048c1b228361bebb5e6d73aeec01696e8cc0e82e2ffef8ab7a"
-dependencies = [
- "proc-macro2",
- "quote",
- "schemars 0.8.22",
- "semver",
- "serde",
- "serde_json",
- "serde_tokenstream",
- "syn 2.0.117",
- "typify-impl",
-]
+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
 
 [[package]]
 name = "uint"
@@ -8922,9 +9111,9 @@ dependencies = [
 
 [[package]]
 name = "unicode-segmentation"
-version = "1.13.2"
+version = "1.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9629274872b2bfaf8d66f5f15725007f635594914870f65218920345aa11aa8c"
+checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"
 
 [[package]]
 name = "unicode-truncate"
@@ -8961,12 +9150,6 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "81e544489bf3d8ef66c953931f56617f423cd4b5494be343d9b9d3dda037b9a3"
 
-[[package]]
-name = "unsafe-libyaml"
-version = "0.2.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
-
 [[package]]
 name = "untrusted"
 version = "0.9.0"
@@ -9037,37 +9220,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
 
-[[package]]
-name = "vcpkg"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
-
-[[package]]
-name = "vector-search-bench"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "arrow-array",
- "arrow-buffer",
- "arrow-schema",
- "clap",
- "futures",
- "indicatif",
- "parquet",
- "rand 0.10.1",
- "rand_distr 0.6.0",
- "serde",
- "tabled",
- "tempfile",
- "tokio",
- "tracing",
- "vortex",
- "vortex-bench",
- "vortex-btrblocks",
- "vortex-tensor",
-]
-
 [[package]]
 name = "version_check"
 version = "0.9.5"
@@ -9095,7 +9247,6 @@ dependencies = [
  "vortex",
  "vortex-alp",
  "vortex-array",
- "vortex-bench",
  "vortex-btrblocks",
  "vortex-buffer",
  "vortex-bytebool",
@@ -9131,7 +9282,7 @@ dependencies = [
  "codspeed-divan-compat",
  "itertools 0.14.0",
  "num-traits",
- "prost 0.14.3",
+ "prost 0.14.4",
  "rand 0.10.1",
  "rstest",
  "rustc-hash",
@@ -9175,14 +9326,13 @@ dependencies = [
  "inventory",
  "itertools 0.14.0",
  "jiff",
- "multiversion",
  "num-traits",
  "num_enum",
  "parking_lot",
  "paste",
  "pin-project-lite",
  "primitive-types",
- "prost 0.14.3",
+ "prost 0.14.4",
  "rand 0.10.1",
  "rand_distr 0.6.0",
  "rstest",
@@ -9196,6 +9346,7 @@ dependencies = [
  "static_assertions",
  "tabled",
  "termtree",
+ "test-with",
  "tracing",
  "uuid",
  "vortex-array",
@@ -9227,7 +9378,6 @@ dependencies = [
  "arrow-schema",
  "arrow-select",
  "async-trait",
- "bytes",
  "bzip2",
  "clap",
  "futures",
@@ -9264,60 +9414,6 @@ dependencies = [
  "vortex-tensor",
 ]
 
-[[package]]
-name = "vortex-bench-migrate"
-version = "0.1.0-alpha.0"
-dependencies = [
- "anyhow",
- "arrow-array",
- "arrow-buffer",
- "arrow-schema",
- "clap",
- "duckdb",
- "flate2",
- "reqwest 0.13.4",
- "rstest",
- "serde",
- "serde_json",
- "tempfile",
- "tokio",
- "tracing",
- "tracing-subscriber",
- "vortex-bench-server",
- "vortex-utils",
-]
-
-[[package]]
-name = "vortex-bench-server"
-version = "0.1.0-alpha.0"
-dependencies = [
- "anyhow",
- "axum",
- "base64",
- "brotli",
- "bytes",
- "dashmap",
- "duckdb",
- "flate2",
- "futures",
- "insta",
- "maud",
- "parking_lot",
- "reqwest 0.13.4",
- "serde",
- "serde_json",
- "subtle",
- "tempfile",
- "thiserror 2.0.18",
- "tokio",
- "tower",
- "tower-http",
- "tracing",
- "tracing-subscriber",
- "twox-hash",
- "vortex-utils",
-]
-
 [[package]]
 name = "vortex-btrblocks"
 version = "0.1.0"
@@ -9328,9 +9424,7 @@ dependencies = [
  "pco",
  "rand 0.10.1",
  "rstest",
- "rustc-hash",
  "test-with",
- "tracing",
  "vortex-alp",
  "vortex-array",
  "vortex-buffer",
@@ -9340,14 +9434,12 @@ dependencies = [
  "vortex-error",
  "vortex-fastlanes",
  "vortex-fsst",
- "vortex-mask",
  "vortex-onpair",
  "vortex-pco",
  "vortex-runend",
  "vortex-sequence",
  "vortex-session",
  "vortex-sparse",
- "vortex-tensor",
  "vortex-utils",
  "vortex-zigzag",
  "vortex-zstd",
@@ -9460,7 +9552,7 @@ dependencies = [
  "num-traits",
  "object_store 0.13.2",
  "parking_lot",
- "prost 0.14.3",
+ "prost 0.14.4",
  "rstest",
  "tokio",
  "tracing",
@@ -9474,6 +9566,19 @@ dependencies = [
  "vortex-nvcomp",
 ]
 
+[[package]]
+name = "vortex-cuda-ffi"
+version = "0.1.0"
+dependencies = [
+ "arrow-schema",
+ "futures",
+ "vortex",
+ "vortex-array",
+ "vortex-cuda",
+ "vortex-cuda-macros",
+ "vortex-ffi",
+]
+
 [[package]]
 name = "vortex-cuda-macros"
 version = "0.1.0"
@@ -9504,19 +9609,19 @@ dependencies = [
  "anyhow",
  "arrow-schema",
  "async-trait",
- "datafusion",
- "datafusion-catalog",
- "datafusion-common",
- "datafusion-common-runtime",
- "datafusion-datasource",
- "datafusion-execution",
- "datafusion-expr",
- "datafusion-functions",
- "datafusion-physical-expr",
- "datafusion-physical-expr-adapter",
- "datafusion-physical-expr-common",
- "datafusion-physical-plan",
- "datafusion-pruning",
+ "datafusion 54.0.0",
+ "datafusion-catalog 54.0.0",
+ "datafusion-common 54.0.0",
+ "datafusion-common-runtime 54.0.0",
+ "datafusion-datasource 54.0.0",
+ "datafusion-execution 54.0.0",
+ "datafusion-expr 54.0.0",
+ "datafusion-functions 54.0.0",
+ "datafusion-physical-expr 54.0.0",
+ "datafusion-physical-expr-adapter 54.0.0",
+ "datafusion-physical-expr-common 54.0.0",
+ "datafusion-physical-plan 54.0.0",
+ "datafusion-pruning 54.0.0",
  "futures",
  "insta",
  "itertools 0.14.0",
@@ -9537,7 +9642,7 @@ name = "vortex-datetime-parts"
 version = "0.1.0"
 dependencies = [
  "num-traits",
- "prost 0.14.3",
+ "prost 0.14.4",
  "rstest",
  "vortex-array",
  "vortex-buffer",
@@ -9551,7 +9656,7 @@ name = "vortex-decimal-byte-parts"
 version = "0.1.0"
 dependencies = [
  "num-traits",
- "prost 0.14.3",
+ "prost 0.14.4",
  "rstest",
  "vortex-array",
  "vortex-buffer",
@@ -9573,6 +9678,7 @@ dependencies = [
  "cc",
  "custom-labels",
  "futures",
+ "geo-types",
  "itertools 0.14.0",
  "jiff",
  "kanal",
@@ -9589,10 +9695,12 @@ dependencies = [
  "url",
  "vortex",
  "vortex-array",
+ "vortex-geo",
  "vortex-runend",
  "vortex-sequence",
  "vortex-utils",
- "zip 8.6.0",
+ "wkb",
+ "zip",
 ]
 
 [[package]]
@@ -9603,7 +9711,7 @@ dependencies = [
  "flatbuffers",
  "jiff",
  "object_store 0.13.2",
- "prost 0.14.3",
+ "prost 0.14.4",
  "serial_test",
  "temp-env",
  "tokio",
@@ -9618,7 +9726,7 @@ dependencies = [
  "itertools 0.14.0",
  "lending-iterator",
  "num-traits",
- "prost 0.14.3",
+ "prost 0.14.4",
  "rand 0.10.1",
  "rstest",
  "vortex-alp",
@@ -9643,7 +9751,7 @@ dependencies = [
  "mimalloc",
  "object_store 0.13.2",
  "paste",
- "prost 0.14.3",
+ "prost 0.14.4",
  "rand 0.10.1",
  "tempfile",
  "tracing",
@@ -9713,7 +9821,7 @@ version = "0.1.0"
 dependencies = [
  "codspeed-divan-compat",
  "fsst-rs",
- "prost 0.14.3",
+ "prost 0.14.4",
  "rand 0.10.1",
  "rstest",
  "test-with",
@@ -9750,6 +9858,22 @@ dependencies = [
  "vortex-utils",
 ]
 
+[[package]]
+name = "vortex-geo"
+version = "0.1.0"
+dependencies = [
+ "arrow-array",
+ "arrow-schema",
+ "geo-traits",
+ "geo-types",
+ "geoarrow",
+ "prost 0.14.4",
+ "vortex-array",
+ "vortex-error",
+ "vortex-session",
+ "wkb",
+]
+
 [[package]]
 name = "vortex-io"
 version = "0.1.0"
@@ -9811,11 +9935,24 @@ dependencies = [
  "jni",
  "object_store 0.13.2",
  "parking_lot",
+ "roaring",
  "thiserror 2.0.18",
  "tracing",
  "tracing-subscriber",
  "url",
  "vortex",
+ "vortex-parquet-variant",
+]
+
+[[package]]
+name = "vortex-json"
+version = "0.1.0"
+dependencies = [
+ "arrow-array",
+ "arrow-schema",
+ "vortex-array",
+ "vortex-error",
+ "vortex-session",
 ]
 
 [[package]]
@@ -9838,7 +9975,7 @@ dependencies = [
  "parking_lot",
  "paste",
  "pin-project-lite",
- "prost 0.14.3",
+ "prost 0.14.4",
  "rstest",
  "rustc-hash",
  "sketches-ddsketch",
@@ -9865,7 +10002,6 @@ dependencies = [
 name = "vortex-mask"
 version = "0.1.0"
 dependencies = [
- "arrow-buffer",
  "codspeed-divan-compat",
  "itertools 0.14.0",
  "rstest",
@@ -9902,7 +10038,7 @@ dependencies = [
  "memchr",
  "num-traits",
  "onpair",
- "prost 0.14.3",
+ "prost 0.14.4",
  "rstest",
  "vortex-array",
  "vortex-buffer",
@@ -9921,7 +10057,7 @@ dependencies = [
  "chrono",
  "parquet-variant",
  "parquet-variant-compute",
- "prost 0.14.3",
+ "prost 0.14.4",
  "rstest",
  "tokio",
  "vortex-array",
@@ -9940,7 +10076,7 @@ name = "vortex-pco"
 version = "0.1.0"
 dependencies = [
  "pco",
- "prost 0.14.3",
+ "prost 0.14.4",
  "rstest",
  "vortex-array",
  "vortex-buffer",
@@ -9953,7 +10089,7 @@ dependencies = [
 name = "vortex-proto"
 version = "0.1.0"
 dependencies = [
- "prost 0.14.3",
+ "prost 0.14.4",
  "prost-types",
 ]
 
@@ -9981,6 +10117,26 @@ dependencies = [
  "vortex-tui",
 ]
 
+[[package]]
+name = "vortex-row"
+version = "0.1.0"
+dependencies = [
+ "arrow-array",
+ "arrow-row",
+ "arrow-schema",
+ "bytes",
+ "codspeed-divan-compat",
+ "mimalloc",
+ "rand 0.10.1",
+ "rstest",
+ "smallvec",
+ "vortex-array",
+ "vortex-buffer",
+ "vortex-error",
+ "vortex-mask",
+ "vortex-session",
+]
+
 [[package]]
 name = "vortex-runend"
 version = "0.1.0"
@@ -9991,7 +10147,7 @@ dependencies = [
  "codspeed-divan-compat",
  "itertools 0.14.0",
  "num-traits",
- "prost 0.14.3",
+ "prost 0.14.4",
  "rand 0.10.1",
  "rstest",
  "vortex-array",
@@ -10022,7 +10178,7 @@ version = "0.1.0"
 dependencies = [
  "itertools 0.14.0",
  "num-traits",
- "prost 0.14.3",
+ "prost 0.14.4",
  "rstest",
  "smallvec",
  "vortex-array",
@@ -10051,7 +10207,7 @@ dependencies = [
  "codspeed-divan-compat",
  "itertools 0.14.0",
  "num-traits",
- "prost 0.14.3",
+ "prost 0.14.4",
  "rstest",
  "vortex-array",
  "vortex-buffer",
@@ -10068,7 +10224,7 @@ dependencies = [
  "async-trait",
  "bigdecimal",
  "clap",
- "datafusion",
+ "datafusion 54.0.0",
  "datafusion-sqllogictest",
  "futures",
  "indicatif",
@@ -10092,7 +10248,7 @@ dependencies = [
  "itertools 0.14.0",
  "mimalloc",
  "num-traits",
- "prost 0.14.3",
+ "prost 0.14.4",
  "rand 0.10.1",
  "rand_distr 0.6.0",
  "rstest",
@@ -10101,7 +10257,6 @@ dependencies = [
  "vortex-buffer",
  "vortex-compressor",
  "vortex-error",
- "vortex-fastlanes",
  "vortex-session",
  "vortex-utils",
 ]
@@ -10126,8 +10281,8 @@ dependencies = [
  "arrow-schema",
  "clap",
  "console_error_panic_hook",
- "crossterm 0.29.0",
- "datafusion",
+ "crossterm",
+ "datafusion 54.0.0",
  "env_logger",
  "flatbuffers",
  "futures",
@@ -10150,35 +10305,12 @@ dependencies = [
  "web-sys",
 ]
 
-[[package]]
-name = "vortex-turboquant"
-version = "0.1.0"
-dependencies = [
- "codspeed-divan-compat",
- "half",
- "num-traits",
- "prost 0.14.3",
- "rand 0.10.1",
- "rstest",
- "vortex-array",
- "vortex-buffer",
- "vortex-error",
- "vortex-file",
- "vortex-io",
- "vortex-layout",
- "vortex-mask",
- "vortex-session",
- "vortex-tensor",
- "vortex-utils",
-]
-
 [[package]]
 name = "vortex-utils"
 version = "0.1.0"
 dependencies = [
  "dashmap",
  "hashbrown 0.17.1",
- "parking_lot",
  "vortex-error",
 ]
 
@@ -10219,7 +10351,7 @@ version = "0.1.0"
 dependencies = [
  "codspeed-divan-compat",
  "itertools 0.14.0",
- "prost 0.14.3",
+ "prost 0.14.4",
  "rstest",
  "vortex-array",
  "vortex-buffer",
@@ -10281,7 +10413,6 @@ dependencies = [
  "cfg-if",
  "once_cell",
  "rustversion",
- "serde",
  "wasm-bindgen-macro",
  "wasm-bindgen-shared",
 ]
@@ -10417,20 +10548,11 @@ dependencies = [
  "rustls-pki-types",
 ]
 
-[[package]]
-name = "webpki-roots"
-version = "1.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52f5ee44c96cf55f1b349600768e3ece3a8f26010c05265ab73f945bb1a2eb9d"
-dependencies = [
- "rustls-pki-types",
-]
-
 [[package]]
 name = "which"
-version = "8.0.2"
+version = "8.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81995fafaaaf6ae47a7d0cc83c67caf92aeb7e5331650ae6ff856f7c0c60c459"
+checksum = "c789537cf2f7f55be8e6192f92e464174ee55f91af622777f7f1ceb0dbccd03e"
 dependencies = [
  "libc",
 ]
@@ -10584,7 +10706,7 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows-targets",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -10593,7 +10715,16 @@ version = "0.59.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
 dependencies = [
- "windows-targets",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.5",
 ]
 
 [[package]]
@@ -10611,14 +10742,31 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_gnullvm",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
+dependencies = [
+ "windows-link",
+ "windows_aarch64_gnullvm 0.53.1",
+ "windows_aarch64_msvc 0.53.1",
+ "windows_i686_gnu 0.53.1",
+ "windows_i686_gnullvm 0.53.1",
+ "windows_i686_msvc 0.53.1",
+ "windows_x86_64_gnu 0.53.1",
+ "windows_x86_64_gnullvm 0.53.1",
+ "windows_x86_64_msvc 0.53.1",
 ]
 
 [[package]]
@@ -10636,48 +10784,96 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
+
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
+
 [[package]]
 name = "winnow"
 version = "0.7.15"
@@ -10787,6 +10983,31 @@ dependencies = [
  "wasmparser",
 ]
 
+[[package]]
+name = "wkb"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a120b336c7ad17749026d50427c23d838ecb50cd64aaea6254b5030152f890a9"
+dependencies = [
+ "byteorder",
+ "geo-traits",
+ "num_enum",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "wkt"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efb2b923ccc882312e559ffaa832a055ba9d1ac0cc8e86b3e25453247e4b81d7"
+dependencies = [
+ "geo-traits",
+ "geo-types",
+ "log",
+ "num-traits",
+ "thiserror 1.0.69",
+]
+
 [[package]]
 name = "writeable"
 version = "0.6.3"
@@ -10809,7 +11030,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156"
 dependencies = [
  "libc",
- "rustix 1.1.4",
+ "rustix",
 ]
 
 [[package]]
@@ -10852,9 +11073,9 @@ checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
 
 [[package]]
 name = "yoke"
-version = "0.8.2"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abe8c5fda708d9ca3df187cae8bfb9ceda00dd96231bed36e445a1a48e66f9ca"
+checksum = "709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5"
 dependencies = [
  "stable_deref_trait",
  "yoke-derive",
@@ -10875,18 +11096,18 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.8.48"
+version = "0.8.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eed437bf9d6692032087e337407a86f04cd8d6a16a37199ed57949d415bd68e9"
+checksum = "3b065d4f0e55f82fae73202e189638116a87c55ab6b8e6c2721e13dd9d854ad1"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.48"
+version = "0.8.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70e3cd084b1788766f53af483dd21f93881ff30d7320490ec3ef7526d203bad4"
+checksum = "0b631b19d36a892ab55420c92dbc83ccd79274f25be714855d3074aa71cab639"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -10962,20 +11183,6 @@ dependencies = [
  "num-traits",
 ]
 
-[[package]]
-name = "zip"
-version = "6.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb2a05c7c36fde6c09b08576c9f7fb4cda705990f73b58fe011abf7dfb24168b"
-dependencies = [
- "arbitrary",
- "crc32fast",
- "flate2",
- "indexmap 2.14.0",
- "memchr",
- "zopfli",
-]
-
 [[package]]
 name = "zip"
 version = "8.6.0"
@@ -10995,7 +11202,7 @@ dependencies = [
  "memchr",
  "pbkdf2",
  "ppmd-rust",
- "sha1 0.11.0",
+ "sha1",
  "time",
  "typed-path",
  "zeroize",
diff --git a/Cargo.toml b/Cargo.toml
index 9700d8d78ed..a587ef1db16 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,8 +12,9 @@ members = [
     "vortex-io",
     "vortex-proto",
     "vortex-array",
+    "vortex-row",
     "vortex-tensor",
-    "vortex-turboquant",
+    "vortex-json",
     "vortex-compressor",
     "vortex-btrblocks",
     "vortex-layout",
@@ -26,6 +27,7 @@ members = [
     "vortex-duckdb",
     "vortex-cuda",
     "vortex-cuda/cub",
+    "vortex-cuda/ffi",
     "vortex-cuda/gpu-scan-cli",
     "vortex-cuda/macros",
     "vortex-cuda/nvcomp",
@@ -62,10 +64,7 @@ members = [
     "benchmarks/datafusion-bench",
     "benchmarks/duckdb-bench",
     "benchmarks/random-access-bench",
-    "benchmarks/vector-search-bench",
-    # Benchmarks website v3 (alpha) - leaf binary, not part of vortex-* API
-    "benchmarks-website/server",
-    "benchmarks-website/migrate",
+    "vortex-geo",
 ]
 exclude = ["java/testfiles", "wasm-test"]
 resolver = "2"
@@ -97,16 +96,17 @@ anyhow = "1.0.97"
 arbitrary = "1.3.2"
 arc-swap = "1.9"
 arcref = "0.2.0"
-arrow-arith = "58"
-arrow-array = "58"
-arrow-buffer = "58"
-arrow-cast = "58"
-arrow-data = "58"
-arrow-ipc = "58"
-arrow-ord = "58"
-arrow-schema = "58"
-arrow-select = "58"
-arrow-string = "58"
+arrow-arith = "58.3"
+arrow-array = "58.3"
+arrow-buffer = "58.3"
+arrow-cast = "58.3"
+arrow-data = "58.3"
+arrow-ipc = "58.3"
+arrow-ord = "58.3"
+arrow-row = "58.3"
+arrow-schema = "58.3"
+arrow-select = "58.3"
+arrow-string = "58.3"
 async-fs = "2.2.0"
 async-lock = "3.4"
 async-stream = "0.3.6"
@@ -134,34 +134,37 @@ cudarc = { version = "0.19.0", features = [
 ] }
 custom-labels = "0.4.4"
 dashmap = "6.1.0"
-datafusion = { version = "53", default-features = false, features = ["sql"] }
-datafusion-catalog = { version = "53" }
-datafusion-common = { version = "53" }
-datafusion-common-runtime = { version = "53" }
-datafusion-datasource = { version = "53", default-features = false }
-datafusion-execution = { version = "53" }
-datafusion-expr = { version = "53" }
-datafusion-functions = { version = "53" }
-datafusion-physical-expr = { version = "53" }
-datafusion-physical-expr-adapter = { version = "53" }
-datafusion-physical-expr-common = { version = "53" }
-datafusion-physical-plan = { version = "53" }
-datafusion-pruning = { version = "53" }
-datafusion-sqllogictest = { version = "53" }
+datafusion = { version = "54", default-features = false, features = ["sql"] }
+datafusion-catalog = { version = "54" }
+datafusion-common = { version = "54" }
+datafusion-common-runtime = { version = "54" }
+datafusion-datasource = { version = "54", default-features = false }
+datafusion-execution = { version = "54" }
+datafusion-expr = { version = "54" }
+datafusion-functions = { version = "54" }
+datafusion-physical-expr = { version = "54" }
+datafusion-physical-expr-adapter = { version = "54" }
+datafusion-physical-expr-common = { version = "54" }
+datafusion-physical-plan = { version = "54" }
+datafusion-pruning = { version = "54" }
+datafusion-sqllogictest = { version = "54" }
 dirs = "6.0.0"
 divan = { package = "codspeed-divan-compat", version = "4.0.4" }
 enum-iterator = "2.0.0"
 env_logger = "0.11"
-fastlanes = "0.5"
+fastlanes = "0.5.1"
 flatbuffers = "25.2.10"
-fsst-rs = "0.5.5"
+fsst-rs = "0.5.11"
 futures = { version = "0.3.31", default-features = false }
 fuzzy-matcher = "0.3"
+geo-traits = "0.3.0"
+geo-types = "0.7.19"
+geoarrow = "0.8.0"
 get_dir = "0.5.0"
 glob = "0.3.2"
 goldenfile = "1"
 half = { version = "2.7.1", features = ["std", "num-traits"] }
-hashbrown = "0.17.0"
+hashbrown = "0.17.1"
 humansize = "2.1.3"
 indicatif = "0.18.0"
 insta = "1.43"
@@ -187,7 +190,7 @@ noodles-bgzf = "0.47.0"
 noodles-vcf = { version = "0.88.0", features = ["async"] }
 num-traits = "0.2.19"
 num_enum = { version = "0.7.3", default-features = false }
-object_store = { version = "0.13.1", default-features = false }
+object_store = { version = "0.13.2", default-features = false }
 once_cell = "1.21"
 oneshot = { version = "0.2.0", features = ["async"] }
 onpair = { version = "0.0.4" }
@@ -195,9 +198,9 @@ opentelemetry = "0.32.0"
 opentelemetry-otlp = "0.32.0"
 opentelemetry_sdk = "0.32.0"
 parking_lot = { version = "0.12.3", features = ["nightly"] }
-parquet = "58"
-parquet-variant = "58"
-parquet-variant-compute = "58"
+parquet = "58.3"
+parquet-variant = "58.3"
+parquet-variant-compute = "58.3"
 paste = "1.0.15"
 pco = "1.0.1"
 pin-project-lite = "0.2.15"
@@ -226,7 +229,7 @@ reqwest = { version = "0.13.0", features = [
 roaring = "0.11.0"
 rstest = "0.26.1"
 rstest_reuse = "0.7.0"
-rustc-hash = "2.1"
+rustc-hash = "2.1.1"
 serde = "1.0.220"
 serde_json = "1.0.138"
 serde_test = "1.0.176"
@@ -240,7 +243,7 @@ static_assertions = "1.1"
 strum = "0.28"
 syn = { version = "2.0.117", features = ["full"] }
 sysinfo = "0.38.0"
-tabled = { version = "0.20.0", default-features = false }
+tabled = { version = "0.21.0", default-features = false }
 taffy = "0.10.0"
 take_mut = "0.2.2"
 tar = "0.4"
@@ -250,7 +253,7 @@ tempfile = "3"
 termtree = { version = "1.0" }
 test-with = "0.16"
 thiserror = "2.0.3"
-tokio = { version = "1.48" }
+tokio = { version = "1.52" }
 tokio-stream = "0.1.17"
 tokio-util = "0.7.17"
 vortex-array-macros = { version = "0.1.0", path = "./vortex-array-macros" }
@@ -261,8 +264,9 @@ tracing = { version = "0.1.41", default-features = false }
 tracing-perfetto = "0.1.5"
 tracing-subscriber = "0.3"
 url = "2.5.7"
-uuid = { version = "1.21", features = ["js"] }
+uuid = { version = "1.23", features = ["js"] }
 wasm-bindgen-futures = "0.4.54"
+wkb = "0.9.2"
 xshell = "0.2.6"
 zigzag = "0.1.0"
 zip = "8.0.0"
@@ -286,8 +290,10 @@ vortex-fastlanes = { version = "0.1.0", path = "./encodings/fastlanes", default-
 vortex-file = { version = "0.1.0", path = "./vortex-file", default-features = false }
 vortex-flatbuffers = { version = "0.1.0", path = "./vortex-flatbuffers", default-features = false }
 vortex-fsst = { version = "0.1.0", path = "./encodings/fsst", default-features = false }
+vortex-geo = { version = "0.1.0", path = "./vortex-geo", default-features = false }
 vortex-io = { version = "0.1.0", path = "./vortex-io", default-features = false }
 vortex-ipc = { version = "0.1.0", path = "./vortex-ipc", default-features = false }
+vortex-json = { version = "0.1.0", path = "./vortex-json", default-features = false }
 vortex-layout = { version = "0.1.0", path = "./vortex-layout", default-features = false }
 vortex-mask = { version = "0.1.0", path = "./vortex-mask", default-features = false }
 vortex-metrics = { version = "0.1.0", path = "./vortex-metrics", default-features = false }
@@ -295,13 +301,13 @@ vortex-onpair = { version = "0.1.0", path = "./encodings/experimental/onpair", d
 vortex-parquet-variant = { version = "0.1.0", path = "./encodings/parquet-variant" }
 vortex-pco = { version = "0.1.0", path = "./encodings/pco", default-features = false }
 vortex-proto = { version = "0.1.0", path = "./vortex-proto", default-features = false }
+vortex-row = { version = "0.1.0", path = "./vortex-row", default-features = false }
 vortex-runend = { version = "0.1.0", path = "./encodings/runend", default-features = false }
 vortex-scan = { version = "0.1.0", path = "./vortex-scan", default-features = false }
 vortex-sequence = { version = "0.1.0", path = "encodings/sequence", default-features = false }
 vortex-session = { version = "0.1.0", path = "./vortex-session", default-features = false }
 vortex-sparse = { version = "0.1.0", path = "./encodings/sparse", default-features = false }
 vortex-tensor = { version = "0.1.0", path = "./vortex-tensor", default-features = false }
-vortex-turboquant = { version = "0.1.0", path = "./vortex-turboquant", default-features = false }
 vortex-utils = { version = "0.1.0", path = "./vortex-utils", default-features = false }
 vortex-zigzag = { version = "0.1.0", path = "./encodings/zigzag", default-features = false }
 vortex-zstd = { version = "0.1.0", path = "./encodings/zstd", default-features = false }
@@ -387,7 +393,7 @@ debug = "full"
 inherits = "release"
 
 [profile.bench]
-codegen-units = 1
+codegen-units = 16
 debug = "full"
 lto = false
 
@@ -409,6 +415,9 @@ incremental = false
 # This rule only applies to dependencies that are not members of the workspace.
 [profile.ci.package."*"]
 debug = false
-debug-assertions = false
-strip = "debuginfo"
+debug-assertions = true
 incremental = false
+
+# This improved build times significantly for default common cases that we use locally
+[profile.dev.package.vortex-fastlanes]
+debug = false
diff --git a/benchmarks-website/AGENTS.md b/benchmarks-website/AGENTS.md
deleted file mode 100644
index 5d1ffde4006..00000000000
--- a/benchmarks-website/AGENTS.md
+++ /dev/null
@@ -1,116 +0,0 @@
-<!--
-SPDX-License-Identifier: Apache-2.0
-SPDX-FileCopyrightText: Copyright the Vortex contributors
--->
-
-# AGENTS.md - `benchmarks-website/`
-
-Read [`README.md`](README.md) first for the architecture and the v2/v3
-side-by-side situation. Then this file. The root [`CLAUDE.md`](../CLAUDE.md)
-covers Rust style, test layout, commit conventions.
-
-## Don't touch the v2 site
-
-Until the cutover PR lands, the top-level v2 files
-(`server.js`, `src/`, `index.html`, `vite.config.js`, `package.json`,
-`package-lock.json`, `public/`, the top-level `Dockerfile`,
-`docker-compose.yml`) and the `publish-benchmarks-website.yml` workflow
-are production. Don't edit them as part of unrelated work.
-
-The v3 deploy lives entirely under `server/`, `migrate/`, and `ops/`.
-The operator runbook is [`ops/README.md`](ops/README.md).
-
-## v3 specifics
-
-- **Wire shapes are a coordinated change.** [`server/src/records.rs`](server/src/records.rs),
-  [`vortex-bench/src/v3.rs`](../vortex-bench/src/v3.rs), and (until cutover)
-  [`migrate/src/classifier.rs`](migrate/src/classifier.rs) must agree.
-  Bumping a shape means changing all three plus the snapshot fixtures in
-  one commit. `SCHEMA_VERSION` is the version literal coupled across two
-  named sites: [`server/src/schema.rs`](server/src/schema.rs) (source of
-  truth) and [`scripts/post-ingest.py`](../scripts/post-ingest.py) (the
-  CI ingest wrapper, which hardcodes it as a Python literal). Bump in
-  lockstep or every CI ingest run 400s. The server-side validation in
-  `records.rs` + `ingest.rs` and the echo in `/health` all consume the
-  constant through `crate::schema`.
-- **Numeric `?n=` is clamped to 1000; `?n=all` is the uncapped escape
-  hatch.** HTML routes hydrate from the materialized latest-100 shard
-  artifact by default; `?n=all` is an explicit opt-in
-  (chart-init.js's full-history zoom-out hop uses it once, and curl
-  power users can request it). The numeric `?n=` path is bounded by
-  `MAX_NUMERIC_COMMIT_WINDOW` in [`server/src/api/window.rs`](server/src/api/window.rs)
-  as a DoS-protection floor against `curl ...?n=99999999`. If you need
-  full history, use `?n=all`. Do NOT raise the numeric cap or remove it
-  without thinking about the DoS surface.
-- **`measurement_id` is server-internal.** Never put it on the wire. It is
-  a deterministic hash over `commit_sha` plus the dim tuple, computed in
-  [`server/src/db.rs`](server/src/db.rs) and reused by the migrator via
-  the same crate.
-- **Don't write a server-side classifier for live ingest.** The emitter
-  produces v3-shape records directly; the migrator's classifier only
-  exists to translate v2 records once and goes away after cutover.
-- **Don't reach for WASM.** SSR + a thin hydration script in
-  [`server/static/chart-init.js`](server/static/chart-init.js) is the
-  whole client.
-- **v3 ingest is no longer best-effort in CI.** The `Ingest results to v3
-  server` step in [`bench.yml`](../.github/workflows/bench.yml),
-  [`sql-benchmarks.yml`](../.github/workflows/sql-benchmarks.yml), and
-  [`v3-commit-metadata.yml`](../.github/workflows/v3-commit-metadata.yml)
-  no longer carries `continue-on-error: true`. A v3-server outage on a
-  develop push now fails the bench workflow and triggers the existing
-  `incident.io` alert. The gate is `vars.V3_INGEST_URL != ''` so forks
-  and unconfigured environments are unaffected.
-- **Don't re-introduce a server-side commit cap on `?n=all`.** `?n=all`
-  is the uncapped escape hatch (chart-init.js fetches it once for the
-  zoom-out path); visual downsampling happens client-side via LTTB on
-  the visible commit range only. Numeric `?n=` is clamped per the bullet
-  above. Default fetches from chart-init.js use the materialized
-  latest-100 shard artifact, not `?n=all`.
-- **Don't refetch on every scope change.** Once a chart's payload is in
-  memory, pan/zoom/slider/range-strip all rebuild in place via the
-  in-memory LTTB pass on the cached payload. The single exception is the
-  latest-100 to full-history zoom-out path: charts initially hydrate from
-  the materialized latest-100 group shard artifact (served from
-  `/api/artifacts/{generation}/groups/{slug}/shards/{i}`); when the user
-  zooms past that window for the first time, `chart-init.js` lazy-fetches
-  `?n=all` once and replaces the latest-100 payload in place.
-
-## Footguns we have already hit
-
-- **Reverse predecessor walk in the tooltip.** `payload.commits[]` is
-  sorted oldest-first by SQL - `commits[0]` is the oldest, `commits[N-1]`
-  is the newest. For per-row delta the predecessor of `commits[idx]` is
-  at `idx - 1`. We caught a regression where a "fix" flipped this to
-  `idx + 1`; the original walk-backward direction is right.
-- **`pointer-events: auto` on the tooltip host.** The tooltip is
-  positioned at the cursor; making it pointer-interactive causes a
-  flicker loop. Keep it `pointer-events: none` and offset via
-  `transform: translate(12px, 12px)`.
-- **`change` events on the slider.** Use `input` events with a small
-  throttle; `change` only fires on release and feels broken.
-
-## Local dev
-
-```bash
-# Public-only run (read API + ingest only, admin routes 404):
-INGEST_BEARER_TOKEN=dev cargo run -p vortex-bench-server
-
-# With admin endpoints mounted on a separate loopback listener:
-INGEST_BEARER_TOKEN=dev ADMIN_BEARER_TOKEN=dev \
-  cargo run -p vortex-bench-server
-
-cargo nextest run -p vortex-bench-server -p vortex-bench-migrate
-INSTA_UPDATE=auto cargo nextest run -p vortex-bench-server   # update snapshots
-```
-
-For the full env-var contract (admin bind, snapshot dir, extension dir,
-logging spec, PaaS `PORT` fallback) see [`ops/config/vortex-bench.env.example`](ops/config/vortex-bench.env.example)
-and the lib-level `//!` doc on [`server/src/main.rs`](server/src/main.rs).
-
-For the migrator end-to-end against the real S3 dump:
-
-```bash
-cargo run -p vortex-bench-migrate -- run --output ./bench.duckdb
-VORTEX_BENCH_DB=./bench.duckdb INGEST_BEARER_TOKEN=dev \
-  cargo run -p vortex-bench-server
-```
diff --git a/benchmarks-website/migrate/Cargo.toml b/benchmarks-website/migrate/Cargo.toml
deleted file mode 100644
index ab448c90e7a..00000000000
--- a/benchmarks-website/migrate/Cargo.toml
+++ /dev/null
@@ -1,41 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-[package]
-name = "vortex-bench-migrate"
-version = "0.1.0-alpha.0"
-edition = "2024"
-rust-version = "1.91.0"
-license = "Apache-2.0"
-description = "One-shot historical migrator from the v2 benchmarks S3 dataset to a v3 DuckDB file"
-publish = false
-
-[[bin]]
-name = "vortex-bench-migrate"
-path = "src/main.rs"
-
-# Throwaway binary, not part of the vortex-* public API surface.
-# Errors use anyhow, and the crate is intentionally outside the
-# workspace.
-
-[dependencies]
-anyhow = { workspace = true }
-arrow-array = { workspace = true }
-arrow-buffer = { workspace = true }
-arrow-schema = { workspace = true }
-clap = { workspace = true, features = ["derive"] }
-# track vortex-duckdb's bundled engine version (build.rs)
-duckdb = { version = "1.10502", features = ["bundled", "appender-arrow"] }
-flate2 = "1.1"
-reqwest = { workspace = true, features = ["json"] }
-serde = { workspace = true, features = ["derive"] }
-serde_json = { workspace = true }
-tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
-tracing = { workspace = true, features = ["std"] }
-tracing-subscriber = { workspace = true, features = ["env-filter", "fmt"] }
-vortex-bench-server = { path = "../server" }
-vortex-utils = { workspace = true }
-
-[dev-dependencies]
-rstest = { workspace = true }
-tempfile = { workspace = true }
diff --git a/benchmarks-website/migrate/build.rs b/benchmarks-website/migrate/build.rs
deleted file mode 100644
index 37bb34d013a..00000000000
--- a/benchmarks-website/migrate/build.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-fn main() {
-    if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("windows") {
-        println!("cargo:rustc-link-lib=dylib=rstrtmgr");
-    }
-}
diff --git a/benchmarks-website/migrate/src/classifier.rs b/benchmarks-website/migrate/src/classifier.rs
deleted file mode 100644
index e473c2a6a02..00000000000
--- a/benchmarks-website/migrate/src/classifier.rs
+++ /dev/null
@@ -1,867 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Bug-for-bug port of v2's `getGroup`, `formatQuery`, and
-//! `normalizeChartName` from `benchmarks-website/server.js`, plus the
-//! mapping from v2 group + name pattern to a v3 fact-table bin.
-//!
-//! The v2 classifier was the source of truth for what historical
-//! records mean. It groups records by name prefix into one of:
-//! "Random Access", "Compression", "Compression Size", or one of the
-//! SQL query suites (with optional fan-out by storage and scale
-//! factor for TPC-H/TPC-DS). This module reproduces that logic and
-//! then hops to a v3 fact-table bin, since v3 stores dim values as
-//! columns instead of name fragments.
-//!
-//! Engine and format strings stored in v3 columns are pulled from the
-//! raw, pre-rename v2 record name. v2's `ENGINE_RENAMES` was a v2
-//! read-time UI concern (e.g. `vortex-file-compressed` rendered as
-//! `vortex` and `parquet-tokio-local-disk` rendered as `parquet-nvme`).
-//! v3 stores canonical `Format::name()` strings to match what the v3
-//! live emitter writes, so historical and live records share series.
-
-use crate::v2::V2Record;
-use crate::v2::dataset_scale_factor;
-
-/// Static port of v2's `QUERY_SUITES`.
-pub const QUERY_SUITES: &[QuerySuite] = &[
-    QuerySuite {
-        prefix: "clickbench",
-        display_name: "Clickbench",
-        query_prefix: "CLICKBENCH",
-        dataset_key: None,
-        fan_out: false,
-        skip: false,
-    },
-    QuerySuite {
-        prefix: "statpopgen",
-        display_name: "Statistical and Population Genetics",
-        query_prefix: "STATPOPGEN",
-        dataset_key: None,
-        fan_out: false,
-        skip: false,
-    },
-    QuerySuite {
-        prefix: "polarsignals",
-        display_name: "PolarSignals Profiling",
-        query_prefix: "POLARSIGNALS",
-        dataset_key: None,
-        fan_out: false,
-        skip: false,
-    },
-    QuerySuite {
-        prefix: "gharchive",
-        display_name: "GhArchive",
-        query_prefix: "GHARCHIVE",
-        dataset_key: None,
-        fan_out: false,
-        skip: false,
-    },
-    QuerySuite {
-        prefix: "tpch",
-        display_name: "TPC-H",
-        query_prefix: "TPC-H",
-        dataset_key: Some("tpch"),
-        fan_out: true,
-        skip: false,
-    },
-    QuerySuite {
-        prefix: "tpcds",
-        display_name: "TPC-DS",
-        query_prefix: "TPC-DS",
-        dataset_key: Some("tpcds"),
-        fan_out: true,
-        skip: false,
-    },
-    QuerySuite {
-        prefix: "fineweb",
-        display_name: "Fineweb",
-        query_prefix: "FINEWEB",
-        dataset_key: None,
-        fan_out: false,
-        skip: false,
-    },
-];
-
-/// Static port of v2's `ENGINE_RENAMES`. Applied to the "series" half
-/// of a benchmark name (the part after the first `/`) before splitting
-/// on `:` into engine/format. Order doesn't matter — keys are unique.
-const ENGINE_RENAMES: &[(&str, &str)] = &[
-    ("datafusion:vortex-file-compressed", "datafusion:vortex"),
-    ("datafusion:parquet", "datafusion:parquet"),
-    ("datafusion:arrow", "datafusion:in-memory-arrow"),
-    ("datafusion:lance", "datafusion:lance"),
-    ("datafusion:vortex-compact", "datafusion:vortex-compact"),
-    ("duckdb:vortex-file-compressed", "duckdb:vortex"),
-    ("duckdb:parquet", "duckdb:parquet"),
-    ("duckdb:duckdb", "duckdb:duckdb"),
-    ("duckdb:vortex-compact", "duckdb:vortex-compact"),
-    ("vortex-tokio-local-disk", "vortex-nvme"),
-    ("vortex-compact-tokio-local-disk", "vortex-compact-nvme"),
-    ("lance-tokio-local-disk", "lance-nvme"),
-    ("parquet-tokio-local-disk", "parquet-nvme"),
-    ("lance", "lance"),
-];
-
-/// One entry of [`QUERY_SUITES`].
-#[derive(Debug, Clone, Copy)]
-pub struct QuerySuite {
-    /// Lowercase suite prefix used to match v2 record names (e.g. `tpch`).
-    pub prefix: &'static str,
-    /// Human-readable suite name as v2 served it from `/api/metadata`.
-    pub display_name: &'static str,
-    /// Uppercase prefix v2's `formatQuery` produced (e.g. `TPC-H`).
-    pub query_prefix: &'static str,
-    /// Override for the dataset key v2 records use inside their `dataset`
-    /// object. Falls back to `prefix` when `None`.
-    pub dataset_key: Option<&'static str>,
-    /// True if the suite's group name fans out by `(storage, scale_factor)`
-    /// (e.g. `TPC-H (NVMe) (SF=1)`); false collapses to a single group.
-    pub fan_out: bool,
-    /// True if v2 deliberately ignored this suite (no live group is rendered).
-    pub skip: bool,
-}
-
-/// Group a v2 record falls into. Mirrors `getGroup` in `server.js`,
-/// including the fan-out group naming for TPC-H/TPC-DS.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum V2Group {
-    RandomAccess,
-    Compression,
-    CompressionSize,
-    Query {
-        suite_index: usize,
-        /// `Some` for fan-out suites only.
-        storage: Option<String>,
-        /// `Some` for fan-out suites only.
-        scale_factor: Option<String>,
-    },
-}
-
-impl V2Group {
-    /// Display name as v2 served it from `/api/metadata`.
-    pub fn display_name(&self) -> String {
-        match self {
-            V2Group::RandomAccess => "Random Access".into(),
-            V2Group::Compression => "Compression".into(),
-            V2Group::CompressionSize => "Compression Size".into(),
-            V2Group::Query {
-                suite_index,
-                storage,
-                scale_factor,
-            } => {
-                let suite = &QUERY_SUITES[*suite_index];
-                if let (Some(storage), Some(sf)) = (storage, scale_factor) {
-                    format!("{} ({}) (SF={})", suite.display_name, storage, sf)
-                } else {
-                    suite.display_name.to_string()
-                }
-            }
-        }
-    }
-}
-
-/// Apply v2's `ENGINE_RENAMES`. Reproduces the JS `rename`:
-/// `RENAMES[s.toLowerCase()] || RENAMES[s] || s`.
-pub fn rename_engine(s: &str) -> String {
-    let lower = s.to_lowercase();
-    for (k, v) in ENGINE_RENAMES {
-        if *k == lower {
-            return (*v).to_string();
-        }
-    }
-    for (k, v) in ENGINE_RENAMES {
-        if *k == s {
-            return (*v).to_string();
-        }
-    }
-    s.to_string()
-}
-
-/// Faithful port of v2's `formatQuery`: maps `clickbench_q07` →
-/// `"CLICKBENCH Q7"`. Returns the original (uppercased,
-/// `-` and `_` replaced with spaces) when no suite matches.
-pub fn format_query(q: &str) -> String {
-    let lower = q.to_lowercase();
-    for suite in QUERY_SUITES {
-        if suite.skip {
-            continue;
-        }
-        let prefix = suite.prefix;
-        if let Some(rest) = lower.strip_prefix(prefix)
-            && let Some(idx) = parse_query_index(rest)
-        {
-            return format!("{} Q{}", suite.query_prefix, idx);
-        }
-    }
-    let mut out = q.to_uppercase();
-    out = out.replace(['_', '-'], " ");
-    out
-}
-
-/// Parse the `_q07` / ` q7` / `q42` tail used by `format_query`.
-/// Returns the integer query index if the tail matches the v2 regex
-/// `^[_ ]?q(\d+)`.
-fn parse_query_index(rest: &str) -> Option<u32> {
-    let after_sep = rest
-        .strip_prefix('_')
-        .or_else(|| rest.strip_prefix(' '))
-        .unwrap_or(rest);
-    let after_q = after_sep
-        .strip_prefix('q')
-        .or_else(|| after_sep.strip_prefix('Q'))?;
-    let digits: String = after_q.chars().take_while(|c| c.is_ascii_digit()).collect();
-    if digits.is_empty() {
-        return None;
-    }
-    digits.parse().ok()
-}
-
-/// Faithful port of v2's `normalizeChartName`.
-pub fn normalize_chart_name(group: &V2Group, chart_name: &str) -> String {
-    if matches!(group, V2Group::CompressionSize) && chart_name == "VORTEX FILE COMPRESSED SIZE" {
-        return "VORTEX SIZE".into();
-    }
-    chart_name.to_string()
-}
-
-/// Port of v2's `getGroup`. Returns `None` for skipped suites
-/// (e.g. `fineweb`) or names that match nothing.
-pub fn get_group(record: &V2Record) -> Option<V2Group> {
-    let lower = record.name.to_lowercase();
-
-    if lower.starts_with("random-access/") || lower.starts_with("random access/") {
-        return Some(V2Group::RandomAccess);
-    }
-
-    if lower.starts_with("vortex size/")
-        || lower.starts_with("vortex-file-compressed size/")
-        || lower.starts_with("parquet size/")
-        || lower.starts_with("parquet-zstd size/")
-        || lower.starts_with("lance size/")
-        || lower.contains(":raw size/")
-        || lower.contains(":parquet-zstd size/")
-        || lower.contains(":lance size/")
-    {
-        return Some(V2Group::CompressionSize);
-    }
-
-    if lower.starts_with("compress time/")
-        || lower.starts_with("decompress time/")
-        || lower.starts_with("parquet_rs-zstd compress")
-        || lower.starts_with("parquet_rs-zstd decompress")
-        || lower.starts_with("lance compress")
-        || lower.starts_with("lance decompress")
-        || lower.starts_with("vortex:lance ratio")
-        || lower.starts_with("vortex:parquet-zstd ratio")
-        // Typo'd v2 emitter wrote `parquet-zst` (no `d`) for some
-        // ratio records; match both spellings so they classify as
-        // derived ratios instead of falling through to Unknown.
-        || lower.starts_with("vortex:parquet-zst ratio")
-        || lower.starts_with("vortex:raw ratio")
-    {
-        return Some(V2Group::Compression);
-    }
-
-    for (i, suite) in QUERY_SUITES.iter().enumerate() {
-        let prefix_q = format!("{}_q", suite.prefix);
-        let prefix_slash = format!("{}/", suite.prefix);
-        if !lower.starts_with(&prefix_q) && !lower.starts_with(&prefix_slash) {
-            continue;
-        }
-        if suite.skip {
-            return None;
-        }
-        if !suite.fan_out {
-            return Some(V2Group::Query {
-                suite_index: i,
-                storage: None,
-                scale_factor: None,
-            });
-        }
-        let storage = match record.storage.as_deref().map(str::to_uppercase).as_deref() {
-            Some("S3") => "S3",
-            _ => "NVMe",
-        };
-        let dataset_key = suite.dataset_key.unwrap_or(suite.prefix);
-        let raw_sf = record
-            .dataset
-            .as_ref()
-            .and_then(|d| dataset_scale_factor(d, dataset_key));
-        let sf = raw_sf
-            .as_deref()
-            .and_then(|s| s.parse::<f64>().ok())
-            .map(|f| f.round() as i64)
-            .unwrap_or(1);
-        return Some(V2Group::Query {
-            suite_index: i,
-            storage: Some(storage.into()),
-            scale_factor: Some(sf.to_string()),
-        });
-    }
-
-    None
-}
-
-/// Group + chart + series breakdown for a v2 record, using the same
-/// rules `server.js` applies in `refresh()`. Equivalent to v2's
-/// `(group, chartName, seriesName)` triple after rename / skip rules.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct V2Classification {
-    /// Group the v2 server would place this record in.
-    pub group: V2Group,
-    /// Chart name v2 displayed for this record (uppercase, separators
-    /// normalized).
-    pub chart: String,
-    /// Series name after v2's `ENGINE_RENAMES` was applied.
-    pub series: String,
-}
-
-/// Apply the same chart / series naming v2's `refresh()` does, plus
-/// the throughput / `PARQUET-UNC` skip rules.
-pub fn classify_v2(record: &V2Record) -> Option<V2Classification> {
-    if record.name.contains(" throughput") {
-        return None;
-    }
-    let group = get_group(record)?;
-    let parts: Vec<&str> = record.name.split('/').collect();
-    let (chart, series) = match (&group, parts.len()) {
-        (V2Group::RandomAccess, 4) => {
-            let chart = format!("{}/{}", parts[1], parts[2])
-                .to_uppercase()
-                .replace(['_', '-'], " ");
-            let series = rename_engine(if parts[3].is_empty() {
-                "default"
-            } else {
-                parts[3]
-            });
-            (chart, series)
-        }
-        (V2Group::RandomAccess, 2) => (
-            "RANDOM ACCESS".to_string(),
-            rename_engine(if parts[1].is_empty() {
-                "default"
-            } else {
-                parts[1]
-            }),
-        ),
-        (V2Group::RandomAccess, _) => return None,
-        _ => {
-            let series_raw = if parts.len() >= 2 && !parts[1].is_empty() {
-                parts[1]
-            } else {
-                "default"
-            };
-            let series = rename_engine(series_raw);
-            let chart = format_query(parts[0]);
-            (chart, series)
-        }
-    };
-    let chart = normalize_chart_name(&group, &chart);
-    if chart.contains("PARQUET-UNC") {
-        return None;
-    }
-    Some(V2Classification {
-        group,
-        chart,
-        series,
-    })
-}
-
-/// Mapping target: which v3 fact table a v2 record lands in, plus the
-/// dim values that table needs.
-#[derive(Debug, Clone, PartialEq)]
-pub enum V3Bin {
-    Query {
-        dataset: String,
-        dataset_variant: Option<String>,
-        scale_factor: Option<String>,
-        query_idx: i32,
-        storage: String,
-        engine: String,
-        format: String,
-    },
-    CompressionTime {
-        dataset: String,
-        dataset_variant: Option<String>,
-        format: String,
-        op: String,
-    },
-    CompressionSize {
-        dataset: String,
-        dataset_variant: Option<String>,
-        format: String,
-    },
-    RandomAccess {
-        dataset: String,
-        format: String,
-    },
-}
-
-/// Top-level entry point. Combines `classify_v2` with the v3 fact-table
-/// mapping. Returns `None` for records that:
-///
-/// - Don't match any v2 group (uncategorized prefix).
-/// - Are explicitly skipped by v2 (throughput, PARQUET-UNC, fineweb).
-/// - Are computed-at-read-time ratios that v3 derives from
-///   `compression_sizes` (`vortex:parquet-zstd ratio …`,
-///   `vortex:lance ratio …`, `vortex:raw ratio …`,
-///   `vortex:* size/…`).
-pub fn classify(record: &V2Record) -> Option<V3Bin> {
-    let cls = classify_v2(record)?;
-    match &cls.group {
-        V2Group::RandomAccess => bin_random_access(record),
-        V2Group::Compression => bin_compression_time(&cls, record),
-        V2Group::CompressionSize => bin_compression_size(&cls, record),
-        V2Group::Query { .. } => bin_query(&cls, record),
-    }
-}
-
-/// Reason the classifier dropped a record. Intentional skips (v2
-/// patterns v3 deliberately doesn't store) are NOT errors; they don't
-/// count against the uncategorized gate.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Skip {
-    /// `vortex:* ratio …` and `vortex:* size` — derived in v3 from
-    /// `compression_sizes` joined to itself.
-    DerivedRatio,
-    /// `throughput` records — v2 derived these from latencies.
-    Throughput,
-    /// A v2 query suite marked `skip: true` in QUERY_SUITES.
-    SkippedSuite,
-    /// random-access record with an unsupported part count.
-    UnsupportedShape,
-    /// Record had no `value` field.
-    NoValue,
-    /// Dim outside the v3 emitter's allowlist (e.g. `parquet-zstd`,
-    /// historical-only suites no longer in CI).
-    Deprecated,
-    /// v2 memory measurements (`*_memory/*` records). Carry top-level
-    /// `peak_physical_memory` / `peak_virtual_memory` /
-    /// `physical_memory_delta` / `virtual_memory_delta` fields that
-    /// `V2Record` doesn't deserialize. Not migrated for alpha; merging
-    /// into the corresponding QueryMeasurement row is future work.
-    HistoricalMemory,
-}
-
-/// Engines the v3 emitter produces today. Mirrors
-/// `vortex-bench/src/lib.rs::Engine`. Anything else is historical and gets
-/// bucketed as `Skip::Deprecated`.
-const V3_ENGINES: &[&str] = &["datafusion", "duckdb", "vortex", "arrow"];
-
-/// Formats the v3 emitter produces today (`Format::name()` values from
-/// `vortex-bench/src/lib.rs`).
-const V3_FORMATS: &[&str] = &[
-    "vortex-file-compressed",
-    "vortex-compact",
-    "parquet",
-    "lance",
-    "csv",
-    "arrow",
-    "duckdb",
-];
-
-/// Query suites the v3 CI runs today. Suites outside this list still
-/// classify (so historical analyses stay coherent) but get bucketed
-/// as `Skip::Deprecated` so they don't render as orphan charts in v3.
-///
-/// `fineweb` is included because `.github/workflows/sql-benchmarks.yml`
-/// still has `fineweb` and `fineweb-s3` matrix entries. `gharchive`
-/// stays excluded — it's defined in `vortex-bench` but no current
-/// workflow runs it.
-const V3_QUERY_SUITES: &[&str] = &[
-    "clickbench",
-    "tpch",
-    "tpcds",
-    "statpopgen",
-    "polarsignals",
-    "fineweb",
-];
-
-/// Returns true if every dim that v3 stores as a column is on the
-/// emitter's current allowlist. Dim values outside the allowlist mean
-/// historical-only formats / engines that the v3 UI has nothing to
-/// render against.
-fn is_v3_dim(bin: &V3Bin) -> bool {
-    match bin {
-        V3Bin::Query { engine, format, .. } => {
-            V3_ENGINES.contains(&engine.as_str()) && V3_FORMATS.contains(&format.as_str())
-        }
-        V3Bin::CompressionTime { format, .. }
-        | V3Bin::CompressionSize { format, .. }
-        | V3Bin::RandomAccess { format, .. } => V3_FORMATS.contains(&format.as_str()),
-    }
-}
-
-/// Outcome of running the classifier on a v2 record. Distinguishes
-/// "we know we don't want this" (`Skip`) from "we don't recognize this"
-/// (`Unknown`); the migrator's 5% gate fires only on the latter.
-#[derive(Debug, Clone)]
-pub enum Outcome {
-    Bin(V3Bin),
-    Skip(Skip),
-    Unknown,
-}
-
-/// Like [`classify`], but reports *why* a record was dropped. Intended
-/// for the migrator so the 5% uncategorized gate doesn't trip on
-/// records v2 deliberately doesn't render (ratios, throughput,
-/// skipped suites).
-pub fn classify_outcome(record: &V2Record) -> Outcome {
-    if record.name.contains(" throughput") {
-        return Outcome::Skip(Skip::Throughput);
-    }
-    // v2 memory records: e.g. "clickbench_q07_memory/datafusion:parquet".
-    // Match the `_memory/` infix BEFORE the engine/format split, so they
-    // route to a known Skip variant instead of slipping through to
-    // Outcome::Unknown and tripping the 5% gate.
-    let lower = record.name.to_lowercase();
-    if let Some((head, _)) = lower.split_once('/')
-        && head.ends_with("_memory")
-    {
-        return Outcome::Skip(Skip::HistoricalMemory);
-    }
-    let Some(group) = get_group(record) else {
-        return Outcome::Unknown;
-    };
-    if let V2Group::Query { suite_index, .. } = &group
-        && QUERY_SUITES[*suite_index].skip
-    {
-        return Outcome::Skip(Skip::SkippedSuite);
-    }
-    let Some(cls) = classify_v2(record) else {
-        // get_group succeeded but classify_v2 didn't — shape mismatch.
-        return Outcome::Skip(Skip::UnsupportedShape);
-    };
-    let derived = match &cls.group {
-        V2Group::Compression => {
-            let lc = cls.chart.to_lowercase();
-            lc.contains("ratio") || lc.contains(':')
-        }
-        V2Group::CompressionSize => cls.chart.to_lowercase().contains(':'),
-        _ => false,
-    };
-    if derived {
-        return Outcome::Skip(Skip::DerivedRatio);
-    }
-    let bin = match &cls.group {
-        V2Group::RandomAccess => match bin_random_access(record) {
-            Some(b) => Some(b),
-            // `bin_random_access` only returns None for malformed
-            // shapes (empty dataset/pattern segment, empty/`default`
-            // format). Route them to Skip so the `Outcome::Unknown`
-            // arm below — and the 5% uncategorized gate in
-            // `migrate::run` — don't trip on them.
-            None => return Outcome::Skip(Skip::UnsupportedShape),
-        },
-        V2Group::Compression => bin_compression_time(&cls, record),
-        V2Group::CompressionSize => bin_compression_size(&cls, record),
-        V2Group::Query { .. } => bin_query(&cls, record),
-    };
-    let Some(bin) = bin else {
-        return Outcome::Unknown;
-    };
-    if !is_v3_dim(&bin) {
-        return Outcome::Skip(Skip::Deprecated);
-    }
-    if let V2Group::Query { suite_index, .. } = &group
-        && !V3_QUERY_SUITES.contains(&QUERY_SUITES[*suite_index].prefix)
-    {
-        return Outcome::Skip(Skip::Deprecated);
-    }
-    Outcome::Bin(bin)
-}
-
-fn bin_random_access(record: &V2Record) -> Option<V3Bin> {
-    // Pull dataset and format from the raw, pre-rename v2 name so v3
-    // stores meaningful values. Two raw shapes are supported:
-    //
-    //   - 4-part `random-access/<dataset>/<pattern>/<format>-tokio-local-disk`
-    //   - 2-part legacy `random-access/<format>-tokio-local-disk`
-    //
-    // The 2-part shape is what `random-access-bench`'s `measurement_name`
-    // emits when called without an `AccessPattern`, and per its source
-    // comment that path is only taken for the legacy taxi run
-    // (`if dataset.name() == "taxi"` in `benchmarks/random-access-bench/
-    // src/main.rs`). The live v3 emitter `random_access_record` writes
-    // `dataset="taxi"` for those same measurements, so the historical
-    // 2-part records are taxi too — assigning `dataset="taxi"` here
-    // recovers the time series instead of letting it disappear under
-    // v2's "RANDOM ACCESS" placeholder. Deriving from the raw name
-    // (rather than `cls.chart`) keeps this independent of v2's
-    // `normalizeChartName`.
-    //
-    // After stripping the `-tokio-local-disk` suffix, map the v2
-    // random-access ext label (`vortex`, from `Format::ext()`) to the
-    // canonical name (`vortex-file-compressed`, from `Format::name()`).
-    // `parquet` and `lance` match between ext and name. The `vortex`
-    // ext is shared by both `OnDiskVortex` (name
-    // `vortex-file-compressed`) and `VortexCompact` (name
-    // `vortex-compact`), but v2's random-access bench only emitted
-    // `OnDiskVortex`, so mapping to `vortex-file-compressed` is
-    // correct for all historical data.
-    //
-    // Records whose `<format>` segment ends in `-footer` (the bench's
-    // reopen-mode variant, e.g. `parquet-tokio-local-disk-footer`)
-    // intentionally do not strip clean to a v3-allowlisted format; the
-    // outer `is_v3_dim` filter then routes them to `Skip::Deprecated`.
-    // The live v3 emitter doesn't distinguish reopen vs cached either
-    // (`random_access_record` uses `format.name()` for both), so
-    // dropping `-footer` here keeps migration consistent with what
-    // v3 ingests live.
-    let parts: Vec<&str> = record.name.split('/').collect();
-    let (dataset, raw_format) = match parts.as_slice() {
-        [_, ds, pat, format] => {
-            if ds.is_empty() || pat.is_empty() {
-                return None;
-            }
-            (format!("{ds}/{pat}").to_lowercase(), *format)
-        }
-        [_, format] => ("taxi".to_string(), *format),
-        _ => return None,
-    };
-    if raw_format.is_empty() || raw_format == "default" {
-        return None;
-    }
-    let stripped = raw_format
-        .strip_suffix("-tokio-local-disk")
-        .unwrap_or(raw_format);
-    let format = match stripped {
-        "vortex" => "vortex-file-compressed".to_string(),
-        other => other.to_lowercase(),
-    };
-    Some(V3Bin::RandomAccess { dataset, format })
-}
-
-fn bin_compression_time(cls: &V2Classification, _record: &V2Record) -> Option<V3Bin> {
-    // v2 compression chart names look like (after format_query):
-    //   "COMPRESS TIME"                                       [vortex/encode]
-    //   "DECOMPRESS TIME"                                     [vortex/decode]
-    //   "PARQUET RS ZSTD COMPRESS TIME"                       [parquet/encode]
-    //   "PARQUET RS ZSTD DECOMPRESS TIME"                     [parquet/decode]
-    //   "LANCE COMPRESS TIME"                                 [lance/encode]
-    //   "LANCE DECOMPRESS TIME"                               [lance/decode]
-    //   "VORTEX:LANCE RATIO COMPRESS TIME"                    [drop]
-    //   "VORTEX:PARQUET-ZSTD RATIO COMPRESS TIME"             [drop]
-    //   "VORTEX:RAW RATIO COMPRESS TIME"                      [drop]
-    let lc = cls.chart.to_lowercase();
-    if lc.contains("ratio") || lc.contains(':') {
-        // Ratios are computed at read time from compression_sizes.
-        return None;
-    }
-    let (format, op) = if lc.starts_with("compress time") {
-        ("vortex-file-compressed", "encode")
-    } else if lc.starts_with("decompress time") {
-        ("vortex-file-compressed", "decode")
-    } else if lc.starts_with("parquet rs zstd compress time") {
-        ("parquet", "encode")
-    } else if lc.starts_with("parquet rs zstd decompress time") {
-        ("parquet", "decode")
-    } else if lc.starts_with("lance compress time") {
-        ("lance", "encode")
-    } else if lc.starts_with("lance decompress time") {
-        ("lance", "decode")
-    } else {
-        return None;
-    };
-    let dataset = cls.series.to_lowercase();
-    if dataset.is_empty() || dataset == "default" {
-        return None;
-    }
-    Some(V3Bin::CompressionTime {
-        dataset,
-        dataset_variant: None,
-        format: format.to_string(),
-        op: op.to_string(),
-    })
-}
-
-fn bin_compression_size(cls: &V2Classification, record: &V2Record) -> Option<V3Bin> {
-    let lc = cls.chart.to_lowercase();
-    // Ratios like "VORTEX:PARQUET ZSTD SIZE" / "VORTEX:LANCE SIZE" /
-    // "VORTEX:RAW SIZE" are derived from compression_sizes at read
-    // time, not stored.
-    if lc.contains(':') {
-        return None;
-    }
-    // `parquet-zstd size` shares a leading "parquet" with `parquet size`,
-    // so check the more specific prefix first. `format_query` upper-cases
-    // and replaces `-`/`_` with spaces, so the chart we match against is
-    // `"PARQUET ZSTD SIZE"` (no hyphen) — same convention as the existing
-    // `"parquet rs zstd compress time"` branches above.
-    let format = if lc.starts_with("vortex size") {
-        "vortex-file-compressed"
-    } else if lc.starts_with("parquet zstd size") {
-        "parquet-zstd"
-    } else if lc.starts_with("parquet size") {
-        "parquet"
-    } else if lc.starts_with("lance size") {
-        "lance"
-    } else {
-        return None;
-    };
-    let dataset = cls.series.to_lowercase();
-    if dataset.is_empty() || dataset == "default" {
-        return None;
-    }
-    // Mirror the file-sizes ingest path's dataset_variant derivation
-    // (see `migrate::migrate_file_sizes`): pull the SF out of the v2
-    // record's `dataset` object when present and run it through
-    // `canonical_scale_factor` so `"1"`, `"1.0"`, `"10"` and `"10.0"`
-    // collapse to one canonical form. Without this both code paths
-    // produce the same `mid` only by accident, so SF=10 file-sizes
-    // rows wouldn't merge with the matching data.json.gz
-    // "vortex size/tpch" rows when one side wrote `"10"` and the
-    // other wrote `"10.0"`.
-    let dataset_variant = crate::v2::canonical_scale_factor(
-        record
-            .dataset
-            .as_ref()
-            .and_then(|d| crate::v2::dataset_scale_factor(d, dataset.as_str()))
-            .as_deref(),
-    );
-    Some(V3Bin::CompressionSize {
-        dataset,
-        dataset_variant,
-        format: format.to_string(),
-    })
-}
-
-fn bin_query(cls: &V2Classification, record: &V2Record) -> Option<V3Bin> {
-    let V2Group::Query {
-        suite_index,
-        storage,
-        scale_factor,
-    } = &cls.group
-    else {
-        return None;
-    };
-    let suite = &QUERY_SUITES[*suite_index];
-
-    // Pull the query index from the *raw* name's first part instead of
-    // the formatted chart, so we don't have to round-trip "Q07".
-    let raw_first = record.name.split('/').next().unwrap_or("");
-    let query_idx = parse_query_index_from_first(raw_first)?;
-
-    // Pull engine:format from the raw, pre-rename second segment so v3
-    // stores canonical `Format::name()` strings (e.g.
-    // `vortex-file-compressed`) that match what the v3 live emitter
-    // writes. `cls.series` has been through v2's `ENGINE_RENAMES` for
-    // UI display and is not appropriate for v3 columns.
-    //
-    // Older v2 records emitted display-case engines (e.g. `DataFusion`,
-    // `DuckDB`); newer ones emit lowercase. Lowercase here so dedup
-    // collapses both spellings into a single canonical row.
-    let raw_series = record.name.split('/').nth(1)?;
-    let (engine, format) = split_engine_format(raw_series)?;
-    let engine = engine.to_lowercase();
-    let format = format.to_lowercase();
-
-    let storage_v3 = match storage.as_deref() {
-        Some("S3") => "s3".to_string(),
-        Some("NVMe") => "nvme".to_string(),
-        _ => "nvme".to_string(),
-    };
-
-    // ClickBench's "flavor" lives in `dataset_variant`, but v2 record names
-    // never encoded it — leave it `None` so historical and live rows merge
-    // (the live emitter does the same; see `vortex-bench/src/v3.rs`'s
-    // `benchmark_dataset_dims` for the matching shape).
-    Some(V3Bin::Query {
-        dataset: suite.prefix.to_string(),
-        dataset_variant: None,
-        scale_factor: scale_factor.clone(),
-        query_idx,
-        storage: storage_v3,
-        engine,
-        format,
-    })
-}
-
-/// Pull the integer query index out of the leading name part, which is
-/// always `<prefix>_q<NN>` or `<prefix> q<NN>` for SQL query records.
-fn parse_query_index_from_first(first: &str) -> Option<i32> {
-    let lower = first.to_lowercase();
-    for suite in QUERY_SUITES {
-        if let Some(rest) = lower.strip_prefix(suite.prefix)
-            && let Some(idx) = parse_query_index(rest)
-        {
-            return Some(idx as i32);
-        }
-    }
-    None
-}
-
-/// Split a renamed series like `datafusion:parquet` into
-/// `(engine, format)`. Returns `None` for series with no `:` since
-/// v3 requires both columns.
-fn split_engine_format(series: &str) -> Option<(String, String)> {
-    let mut split = series.splitn(2, ':');
-    let engine = split.next()?.trim().to_string();
-    let format = split.next()?.trim().to_string();
-    if engine.is_empty() || format.is_empty() {
-        return None;
-    }
-    Some((engine, format))
-}
-
-#[cfg(test)]
-mod tests {
-    use anyhow::Context as _;
-
-    use super::*;
-
-    fn record(name: &str) -> V2Record {
-        V2Record {
-            name: name.to_string(),
-            commit_id: Some("deadbeef".into()),
-            unit: None,
-            value: None,
-            storage: None,
-            dataset: None,
-            all_runtimes: None,
-            env_triple: None,
-        }
-    }
-
-    #[test]
-    fn format_query_round_trips() {
-        assert_eq!(format_query("clickbench_q07"), "CLICKBENCH Q7");
-        assert_eq!(format_query("tpch_q01"), "TPC-H Q1");
-        assert_eq!(format_query("tpcds_q42"), "TPC-DS Q42");
-        assert_eq!(format_query("statpopgen_q3"), "STATPOPGEN Q3");
-        assert_eq!(format_query("foo bar"), "FOO BAR");
-    }
-
-    #[test]
-    fn rename_engine_canonicalizes_disk_names() {
-        assert_eq!(rename_engine("vortex-tokio-local-disk"), "vortex-nvme");
-        assert_eq!(
-            rename_engine("datafusion:vortex-file-compressed"),
-            "datafusion:vortex"
-        );
-        assert_eq!(rename_engine("unknown-engine"), "unknown-engine");
-    }
-
-    #[test]
-    fn parse_query_index_handles_separators() {
-        assert_eq!(parse_query_index("_q07"), Some(7));
-        assert_eq!(parse_query_index(" q7"), Some(7));
-        assert_eq!(parse_query_index("q42"), Some(42));
-        assert_eq!(parse_query_index("xq7"), None);
-    }
-
-    #[test]
-    fn random_access_bins_dataset_pattern() -> anyhow::Result<()> {
-        let bin = classify(&record("random-access/taxi/take/parquet"))
-            .context("classify returned None for a known-good 4-part random-access name")?;
-        assert_eq!(
-            bin,
-            V3Bin::RandomAccess {
-                dataset: "taxi/take".into(),
-                format: "parquet".into(),
-            }
-        );
-        Ok(())
-    }
-}
diff --git a/benchmarks-website/migrate/src/commits.rs b/benchmarks-website/migrate/src/commits.rs
deleted file mode 100644
index a9c5f056cd7..00000000000
--- a/benchmarks-website/migrate/src/commits.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Commit upserts. Adapts a [`crate::v2::V2Commit`] into the v3
-//! `commits` row shape (a [`vortex_bench_server::records::CommitInfo`]).
-
-use anyhow::Context as _;
-use anyhow::Result;
-use duckdb::Transaction;
-use duckdb::params;
-
-use crate::v2::V2Commit;
-
-/// Insert a v3 `commits` row for one v2 commit. `tree_sha` and `url`
-/// remain required and use a warning-bearing empty-string fallback;
-/// the human-input fields (message, author/committer name and email)
-/// are nullable in the v3 schema, so empty / missing values map to
-/// SQL `NULL` instead of an empty string the UI would render as a
-/// blank cell.
-pub fn upsert_commit(tx: &Transaction<'_>, commit: &V2Commit) -> Result<UpsertOutcome> {
-    let mut warnings = Vec::new();
-    let timestamp = require_field(&commit.timestamp, "timestamp", &commit.id, &mut warnings);
-    let message = optional_field(&commit.message);
-    let author_name = optional_field(&commit.author.as_ref().and_then(|p| p.name.clone()));
-    let author_email = optional_field(&commit.author.as_ref().and_then(|p| p.email.clone()));
-    let committer_name = optional_field(&commit.committer.as_ref().and_then(|p| p.name.clone()));
-    let committer_email = optional_field(&commit.committer.as_ref().and_then(|p| p.email.clone()));
-    let tree_sha = require_field(&commit.tree_id, "tree_id", &commit.id, &mut warnings);
-    let url = require_field(&commit.url, "url", &commit.id, &mut warnings);
-
-    tx.execute(
-        r#"
-        INSERT INTO commits (
-            commit_sha, timestamp, message, author_name, author_email,
-            committer_name, committer_email, tree_sha, url
-        ) VALUES (?, CAST(? AS TIMESTAMPTZ), ?, ?, ?, ?, ?, ?, ?)
-        ON CONFLICT (commit_sha) DO UPDATE SET
-            timestamp       = excluded.timestamp,
-            message         = excluded.message,
-            author_name     = excluded.author_name,
-            author_email    = excluded.author_email,
-            committer_name  = excluded.committer_name,
-            committer_email = excluded.committer_email,
-            tree_sha        = excluded.tree_sha,
-            url             = excluded.url
-        "#,
-        params![
-            commit.id,
-            timestamp,
-            message,
-            author_name,
-            author_email,
-            committer_name,
-            committer_email,
-            tree_sha,
-            url,
-        ],
-    )
-    .with_context(|| format!("upserting commit {}", commit.id))?;
-    Ok(UpsertOutcome { warnings })
-}
-
-fn require_field(
-    field: &Option<String>,
-    name: &str,
-    sha: &str,
-    warnings: &mut Vec<String>,
-) -> String {
-    match field {
-        Some(s) => s.clone(),
-        None => {
-            warnings.push(format!("commit {sha} missing {name}"));
-            String::new()
-        }
-    }
-}
-
-/// Coerce a v2-supplied `Option<String>` into a SQL-bindable
-/// `Option<String>`, treating an empty / whitespace-only value as
-/// missing. v2 sometimes wrote `""` for blank author / committer /
-/// message fields; storing those as actual `NULL` lets the UI
-/// distinguish "missing metadata" from "deliberately blank".
-fn optional_field(field: &Option<String>) -> Option<String> {
-    field
-        .as_deref()
-        .map(str::trim)
-        .filter(|s| !s.is_empty())
-        .map(str::to_string)
-}
-
-/// Per-call warning bag returned to the caller for logging.
-#[derive(Debug, Default)]
-pub struct UpsertOutcome {
-    /// Human-readable warnings — typically one per missing required field on
-    /// the v2 commit (timestamp, tree_id, url).
-    pub warnings: Vec<String>,
-}
diff --git a/benchmarks-website/migrate/src/lib.rs b/benchmarks-website/migrate/src/lib.rs
deleted file mode 100644
index b5aa72bc97d..00000000000
--- a/benchmarks-website/migrate/src/lib.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! One-shot historical migrator from v2's S3-hosted benchmark dataset
-//! to a v3 DuckDB file.
-//!
-//! The v2 dataset is JSONL of bare benchmark records keyed by name string.
-//! v3 uses five typed fact tables with explicit dim columns. This crate
-//! ports v2's `getGroup` classifier (in `benchmarks-website/server.js`)
-//! bug-for-bug so that historical rows survive the migration with the
-//! same group / chart / series structure as the live v2 server.
-//!
-//! The migrator is throwaway: once v3 cuts over, both the binary and
-//! the classifier go away.
-
-/// Routing v2 records into v3 fact tables, ported from v2's `getGroup`.
-pub mod classifier;
-/// V2 commit -> v3 `commits` row upserts.
-pub mod commits;
-/// End-to-end migration of v2 dumps into a v3 DuckDB.
-pub mod migrate;
-/// Streaming readers for the v2 S3 bucket and local dumps.
-pub mod source;
-/// Wire shapes of the v2 benchmark dataset.
-pub mod v2;
-/// Structural diff between a migrated v3 DuckDB and v2's `/api/metadata`.
-pub mod verify;
diff --git a/benchmarks-website/migrate/src/main.rs b/benchmarks-website/migrate/src/main.rs
deleted file mode 100644
index abd3a4a8a83..00000000000
--- a/benchmarks-website/migrate/src/main.rs
+++ /dev/null
@@ -1,131 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! `vortex-bench-migrate` CLI: a one-shot historical migrator from
-//! v2's S3 dataset into a v3 DuckDB file, plus a structural diff
-//! against the live v2 `/api/metadata` endpoint for spotting
-//! classifier regressions.
-
-use std::path::PathBuf;
-use std::process::ExitCode;
-
-use anyhow::Context as _;
-use anyhow::Result;
-use clap::Parser;
-use clap::Subcommand;
-use clap::ValueEnum;
-use tracing_subscriber::EnvFilter;
-use vortex_bench_migrate::migrate;
-use vortex_bench_migrate::source::Source;
-use vortex_bench_migrate::verify;
-
-/// One-shot historical migrator from v2's S3 dataset to v3 DuckDB.
-#[derive(Debug, Parser)]
-#[command(name = "vortex-bench-migrate", version, about)]
-struct Cli {
-    #[command(subcommand)]
-    command: Command,
-}
-
-#[derive(Debug, Subcommand)]
-enum Command {
-    /// Read v2's data.json.gz / commits.json / file-sizes-*.json.gz
-    /// and write a fully populated v3 DuckDB at `--output`.
-    Run {
-        /// Path to write the v3 DuckDB to. Created if absent.
-        #[arg(long)]
-        output: PathBuf,
-        /// Where to fetch v2 dumps from.
-        #[arg(long, value_enum, default_value_t = SourceKind::PublicS3)]
-        source: SourceKind,
-        /// For `--source=local`, the directory containing
-        /// `data.json.gz`, `commits.json`, and `file-sizes-*.json.gz`.
-        #[arg(long, required_if_eq("source", "local"))]
-        source_dir: Option<PathBuf>,
-        /// Continue past per-`file-sizes-*.json.gz` failures rather than
-        /// failing the migration. By default a single failed
-        /// `file-sizes-*` source is an error, because a "successful"
-        /// migrated DB with missing compression-size history is a worse
-        /// outcome than a loud failure that the operator can retry. Pass
-        /// this flag when you genuinely want partial coverage (e.g. one
-        /// known-bad source file you want to skip).
-        #[arg(long, default_value_t = false)]
-        allow_missing_file_sizes: bool,
-    },
-    /// Diff a migrated DuckDB against the live v2 `/api/metadata`
-    /// endpoint. Exits 0 if every v2 group is present in v3, 1
-    /// otherwise so this can gate a CI step.
-    Verify {
-        /// HTTPS root of a running v2 server (e.g. `https://bench.vortex.dev`).
-        #[arg(long)]
-        against: String,
-        /// Path to the migrated v3 DuckDB.
-        #[arg(long)]
-        duckdb: PathBuf,
-    },
-}
-
-#[derive(Debug, Clone, Copy, ValueEnum)]
-enum SourceKind {
-    PublicS3,
-    Local,
-}
-
-fn main() -> ExitCode {
-    if let Err(err) = run() {
-        eprintln!("error: {err:#}");
-        return ExitCode::from(2);
-    }
-    ExitCode::SUCCESS
-}
-
-fn run() -> Result<()> {
-    tracing_subscriber::fmt()
-        .with_env_filter(
-            EnvFilter::try_from_env("VORTEX_BENCH_LOG").unwrap_or_else(|_| EnvFilter::new("info")),
-        )
-        .init();
-
-    let cli = Cli::parse();
-    match cli.command {
-        Command::Run {
-            output,
-            source,
-            source_dir,
-            allow_missing_file_sizes,
-        } => {
-            let source = match source {
-                SourceKind::PublicS3 => Source::PublicS3,
-                SourceKind::Local => {
-                    Source::Local(source_dir.context("--source=local requires --source-dir")?)
-                }
-            };
-            let summary = migrate::run(&source, &output)?;
-            print!("{summary}");
-            if summary.uncategorized_fraction() > 0.05 {
-                anyhow::bail!(
-                    "uncategorized records ({:.2}%) exceed the 5% gate; \
-                     stop and report unmatched prefixes (see summary above) \
-                     before proceeding",
-                    100.0 * summary.uncategorized_fraction()
-                );
-            }
-            if summary.file_sizes_failed > 0 && !allow_missing_file_sizes {
-                anyhow::bail!(
-                    "{} file-sizes-*.json.gz source file(s) failed (see warnings above); \
-                     re-run with --allow-missing-file-sizes if partial coverage is intended",
-                    summary.file_sizes_failed
-                );
-            }
-            Ok(())
-        }
-        Command::Verify { against, duckdb } => {
-            let report = verify::run(&against, &duckdb)?;
-            print!("{report}");
-            if !report.v2_groups_covered() {
-                std::process::exit(1);
-            }
-            Ok(())
-        }
-    }
-}
diff --git a/benchmarks-website/migrate/src/migrate/accum.rs b/benchmarks-website/migrate/src/migrate/accum.rs
deleted file mode 100644
index 69f16fe4b93..00000000000
--- a/benchmarks-website/migrate/src/migrate/accum.rs
+++ /dev/null
@@ -1,357 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Per-fact-table row accumulators + their `RecordBatch` builders.
-//!
-//! Each `*Accum` collects classified records during the streaming JSONL
-//! pass and then materialises one Arrow `RecordBatch` per fact table at
-//! flush time. Three of the four use parallel column vectors with a
-//! `seen` map keyed by `measurement_id`; `CompressionSizeAccum` is a
-//! `HashMap<i64, CompressionSize>` because it has two collision semantics
-//! (replace from `data.json.gz`, sum from `file-sizes-*.json.gz`).
-
-use std::sync::Arc;
-
-use anyhow::Result;
-use arrow_array::ArrayRef;
-use arrow_array::Int32Array;
-use arrow_array::Int64Array;
-use arrow_array::ListArray;
-use arrow_array::RecordBatch;
-use arrow_array::StringArray;
-use arrow_buffer::OffsetBuffer;
-use arrow_schema::DataType;
-use arrow_schema::Field;
-use arrow_schema::Schema;
-use vortex_bench_server::records::CompressionSize;
-use vortex_bench_server::records::CompressionTime;
-use vortex_bench_server::records::QueryMeasurement;
-use vortex_bench_server::records::RandomAccessTime;
-use vortex_utils::aliases::hash_map::HashMap;
-
-use super::MigrationSummary;
-
-/// `query_measurements` accumulator. Parallel column vectors plus a
-/// `measurement_id`-keyed seen map; first-write wins on collision.
-#[derive(Default)]
-pub(super) struct QueryAccum {
-    pub(super) measurement_id: Vec<i64>,
-    pub(super) commit_sha: Vec<String>,
-    pub(super) dataset: Vec<String>,
-    pub(super) dataset_variant: Vec<Option<String>>,
-    pub(super) scale_factor: Vec<Option<String>>,
-    pub(super) query_idx: Vec<i32>,
-    pub(super) storage: Vec<String>,
-    pub(super) engine: Vec<String>,
-    pub(super) format: Vec<String>,
-    pub(super) value_ns: Vec<i64>,
-    pub(super) all_runtimes_ns: Vec<Vec<i64>>,
-    pub(super) peak_physical: Vec<Option<i64>>,
-    pub(super) peak_virtual: Vec<Option<i64>>,
-    pub(super) physical_delta: Vec<Option<i64>>,
-    pub(super) virtual_delta: Vec<Option<i64>>,
-    pub(super) env_triple: Vec<Option<String>>,
-    /// `mid` -> index in the parallel column vecs. Lets us look up the
-    /// kept row's `value_ns` on collision so we can flag conflicts.
-    pub(super) seen: HashMap<i64, usize>,
-}
-
-impl QueryAccum {
-    pub(super) fn push(&mut self, mid: i64, r: QueryMeasurement, summary: &mut MigrationSummary) {
-        if let Some(&idx) = self.seen.get(&mid) {
-            summary.deduped += 1;
-            if self.value_ns[idx] != r.value_ns {
-                summary.deduped_with_conflict += 1;
-            }
-            return;
-        }
-        let idx = self.measurement_id.len();
-        self.seen.insert(mid, idx);
-        self.measurement_id.push(mid);
-        self.commit_sha.push(r.commit_sha);
-        self.dataset.push(r.dataset);
-        self.dataset_variant.push(r.dataset_variant);
-        self.scale_factor.push(r.scale_factor);
-        self.query_idx.push(r.query_idx);
-        self.storage.push(r.storage);
-        self.engine.push(r.engine);
-        self.format.push(r.format);
-        self.value_ns.push(r.value_ns);
-        self.all_runtimes_ns.push(r.all_runtimes_ns);
-        self.peak_physical.push(r.peak_physical);
-        self.peak_virtual.push(r.peak_virtual);
-        self.physical_delta.push(r.physical_delta);
-        self.virtual_delta.push(r.virtual_delta);
-        self.env_triple.push(r.env_triple);
-    }
-}
-
-/// `compression_times` accumulator. Same shape as [`QueryAccum`] minus the
-/// query-only columns.
-#[derive(Default)]
-pub(super) struct CompressionTimeAccum {
-    pub(super) measurement_id: Vec<i64>,
-    pub(super) commit_sha: Vec<String>,
-    pub(super) dataset: Vec<String>,
-    pub(super) dataset_variant: Vec<Option<String>>,
-    pub(super) format: Vec<String>,
-    pub(super) op: Vec<String>,
-    pub(super) value_ns: Vec<i64>,
-    pub(super) all_runtimes_ns: Vec<Vec<i64>>,
-    pub(super) env_triple: Vec<Option<String>>,
-    pub(super) seen: HashMap<i64, usize>,
-}
-
-impl CompressionTimeAccum {
-    pub(super) fn push(&mut self, mid: i64, r: CompressionTime, summary: &mut MigrationSummary) {
-        if let Some(&idx) = self.seen.get(&mid) {
-            summary.deduped += 1;
-            if self.value_ns[idx] != r.value_ns {
-                summary.deduped_with_conflict += 1;
-            }
-            return;
-        }
-        let idx = self.measurement_id.len();
-        self.seen.insert(mid, idx);
-        self.measurement_id.push(mid);
-        self.commit_sha.push(r.commit_sha);
-        self.dataset.push(r.dataset);
-        self.dataset_variant.push(r.dataset_variant);
-        self.format.push(r.format);
-        self.op.push(r.op);
-        self.value_ns.push(r.value_ns);
-        self.all_runtimes_ns.push(r.all_runtimes_ns);
-        self.env_triple.push(r.env_triple);
-    }
-}
-
-/// `random_access_times` accumulator. Smallest of the three parallel-vec
-/// accumulators.
-#[derive(Default)]
-pub(super) struct RandomAccessAccum {
-    pub(super) measurement_id: Vec<i64>,
-    pub(super) commit_sha: Vec<String>,
-    pub(super) dataset: Vec<String>,
-    pub(super) format: Vec<String>,
-    pub(super) value_ns: Vec<i64>,
-    pub(super) all_runtimes_ns: Vec<Vec<i64>>,
-    pub(super) env_triple: Vec<Option<String>>,
-    pub(super) seen: HashMap<i64, usize>,
-}
-
-impl RandomAccessAccum {
-    pub(super) fn push(&mut self, mid: i64, r: RandomAccessTime, summary: &mut MigrationSummary) {
-        if let Some(&idx) = self.seen.get(&mid) {
-            summary.deduped += 1;
-            if self.value_ns[idx] != r.value_ns {
-                summary.deduped_with_conflict += 1;
-            }
-            return;
-        }
-        let idx = self.measurement_id.len();
-        self.seen.insert(mid, idx);
-        self.measurement_id.push(mid);
-        self.commit_sha.push(r.commit_sha);
-        self.dataset.push(r.dataset);
-        self.format.push(r.format);
-        self.value_ns.push(r.value_ns);
-        self.all_runtimes_ns.push(r.all_runtimes_ns);
-        self.env_triple.push(r.env_triple);
-    }
-}
-
-/// `compression_sizes` is fed by both `data.json.gz` (replace-on-collision)
-/// and `file-sizes-*.json.gz` (sum-on-collision). Stored as a map; converted
-/// to a `RecordBatch` at flush time.
-#[derive(Default)]
-pub(super) struct CompressionSizeAccum {
-    pub(super) rows: HashMap<i64, CompressionSize>,
-}
-
-impl CompressionSizeAccum {
-    /// data.json.gz path: latest write wins, mirroring the prior
-    /// `ON CONFLICT DO UPDATE SET value_bytes = excluded.value_bytes`.
-    /// Bumps `deduped_with_conflict` when an existing row's
-    /// `value_bytes` differs from the incoming row's, so silent
-    /// value-corruption is observable.
-    pub(super) fn push_replace(
-        &mut self,
-        mid: i64,
-        r: CompressionSize,
-        summary: &mut MigrationSummary,
-    ) {
-        if let Some(existing) = self.rows.get(&mid)
-            && existing.value_bytes != r.value_bytes
-        {
-            summary.deduped_with_conflict += 1;
-        }
-        self.rows.insert(mid, r);
-    }
-
-    /// file-sizes-*.json.gz path: per-file rows aggregate into one
-    /// `(commit, dataset, dataset_variant, format)` row by summing,
-    /// mirroring the prior `value_bytes = compression_sizes.value_bytes
-    /// + excluded.value_bytes`.
-    pub(super) fn push_sum(&mut self, mid: i64, r: CompressionSize) {
-        let add = r.value_bytes;
-        self.rows
-            .entry(mid)
-            .and_modify(|x| x.value_bytes += add)
-            .or_insert(r);
-    }
-}
-
-pub(super) fn build_query_batch(a: QueryAccum) -> Result<RecordBatch> {
-    let schema = Arc::new(Schema::new(vec![
-        Field::new("measurement_id", DataType::Int64, false),
-        Field::new("commit_sha", DataType::Utf8, false),
-        Field::new("dataset", DataType::Utf8, false),
-        Field::new("dataset_variant", DataType::Utf8, true),
-        Field::new("scale_factor", DataType::Utf8, true),
-        Field::new("query_idx", DataType::Int32, false),
-        Field::new("storage", DataType::Utf8, false),
-        Field::new("engine", DataType::Utf8, false),
-        Field::new("format", DataType::Utf8, false),
-        Field::new("value_ns", DataType::Int64, false),
-        Field::new(
-            "all_runtimes_ns",
-            DataType::List(Arc::new(Field::new("item", DataType::Int64, false))),
-            false,
-        ),
-        Field::new("peak_physical", DataType::Int64, true),
-        Field::new("peak_virtual", DataType::Int64, true),
-        Field::new("physical_delta", DataType::Int64, true),
-        Field::new("virtual_delta", DataType::Int64, true),
-        Field::new("env_triple", DataType::Utf8, true),
-    ]));
-    let cols: Vec<ArrayRef> = vec![
-        Arc::new(Int64Array::from(a.measurement_id)),
-        Arc::new(StringArray::from(a.commit_sha)),
-        Arc::new(StringArray::from(a.dataset)),
-        Arc::new(StringArray::from(a.dataset_variant)),
-        Arc::new(StringArray::from(a.scale_factor)),
-        Arc::new(Int32Array::from(a.query_idx)),
-        Arc::new(StringArray::from(a.storage)),
-        Arc::new(StringArray::from(a.engine)),
-        Arc::new(StringArray::from(a.format)),
-        Arc::new(Int64Array::from(a.value_ns)),
-        Arc::new(build_list_int64(a.all_runtimes_ns)),
-        Arc::new(Int64Array::from(a.peak_physical)),
-        Arc::new(Int64Array::from(a.peak_virtual)),
-        Arc::new(Int64Array::from(a.physical_delta)),
-        Arc::new(Int64Array::from(a.virtual_delta)),
-        Arc::new(StringArray::from(a.env_triple)),
-    ];
-    Ok(RecordBatch::try_new(schema, cols)?)
-}
-
-pub(super) fn build_compression_time_batch(a: CompressionTimeAccum) -> Result<RecordBatch> {
-    let schema = Arc::new(Schema::new(vec![
-        Field::new("measurement_id", DataType::Int64, false),
-        Field::new("commit_sha", DataType::Utf8, false),
-        Field::new("dataset", DataType::Utf8, false),
-        Field::new("dataset_variant", DataType::Utf8, true),
-        Field::new("format", DataType::Utf8, false),
-        Field::new("op", DataType::Utf8, false),
-        Field::new("value_ns", DataType::Int64, false),
-        Field::new(
-            "all_runtimes_ns",
-            DataType::List(Arc::new(Field::new("item", DataType::Int64, false))),
-            false,
-        ),
-        Field::new("env_triple", DataType::Utf8, true),
-    ]));
-    let cols: Vec<ArrayRef> = vec![
-        Arc::new(Int64Array::from(a.measurement_id)),
-        Arc::new(StringArray::from(a.commit_sha)),
-        Arc::new(StringArray::from(a.dataset)),
-        Arc::new(StringArray::from(a.dataset_variant)),
-        Arc::new(StringArray::from(a.format)),
-        Arc::new(StringArray::from(a.op)),
-        Arc::new(Int64Array::from(a.value_ns)),
-        Arc::new(build_list_int64(a.all_runtimes_ns)),
-        Arc::new(StringArray::from(a.env_triple)),
-    ];
-    Ok(RecordBatch::try_new(schema, cols)?)
-}
-
-pub(super) fn build_random_access_batch(a: RandomAccessAccum) -> Result<RecordBatch> {
-    let schema = Arc::new(Schema::new(vec![
-        Field::new("measurement_id", DataType::Int64, false),
-        Field::new("commit_sha", DataType::Utf8, false),
-        Field::new("dataset", DataType::Utf8, false),
-        Field::new("format", DataType::Utf8, false),
-        Field::new("value_ns", DataType::Int64, false),
-        Field::new(
-            "all_runtimes_ns",
-            DataType::List(Arc::new(Field::new("item", DataType::Int64, false))),
-            false,
-        ),
-        Field::new("env_triple", DataType::Utf8, true),
-    ]));
-    let cols: Vec<ArrayRef> = vec![
-        Arc::new(Int64Array::from(a.measurement_id)),
-        Arc::new(StringArray::from(a.commit_sha)),
-        Arc::new(StringArray::from(a.dataset)),
-        Arc::new(StringArray::from(a.format)),
-        Arc::new(Int64Array::from(a.value_ns)),
-        Arc::new(build_list_int64(a.all_runtimes_ns)),
-        Arc::new(StringArray::from(a.env_triple)),
-    ];
-    Ok(RecordBatch::try_new(schema, cols)?)
-}
-
-pub(super) fn build_compression_size_batch(a: CompressionSizeAccum) -> Result<RecordBatch> {
-    let n = a.rows.len();
-    let mut measurement_id = Vec::with_capacity(n);
-    let mut commit_sha = Vec::with_capacity(n);
-    let mut dataset = Vec::with_capacity(n);
-    let mut dataset_variant = Vec::with_capacity(n);
-    let mut format = Vec::with_capacity(n);
-    let mut value_bytes = Vec::with_capacity(n);
-    for (mid, cs) in a.rows {
-        measurement_id.push(mid);
-        commit_sha.push(cs.commit_sha);
-        dataset.push(cs.dataset);
-        dataset_variant.push(cs.dataset_variant);
-        format.push(cs.format);
-        value_bytes.push(cs.value_bytes);
-    }
-    let schema = Arc::new(Schema::new(vec![
-        Field::new("measurement_id", DataType::Int64, false),
-        Field::new("commit_sha", DataType::Utf8, false),
-        Field::new("dataset", DataType::Utf8, false),
-        Field::new("dataset_variant", DataType::Utf8, true),
-        Field::new("format", DataType::Utf8, false),
-        Field::new("value_bytes", DataType::Int64, false),
-    ]));
-    let cols: Vec<ArrayRef> = vec![
-        Arc::new(Int64Array::from(measurement_id)),
-        Arc::new(StringArray::from(commit_sha)),
-        Arc::new(StringArray::from(dataset)),
-        Arc::new(StringArray::from(dataset_variant)),
-        Arc::new(StringArray::from(format)),
-        Arc::new(Int64Array::from(value_bytes)),
-    ];
-    Ok(RecordBatch::try_new(schema, cols)?)
-}
-
-/// Build a non-nullable `List<Int64>` Arrow array from one inner Vec
-/// per row. The outer list is non-null; inner i64 values are non-null.
-fn build_list_int64(values: Vec<Vec<i64>>) -> ListArray {
-    let mut offsets: Vec<i32> = Vec::with_capacity(values.len() + 1);
-    offsets.push(0);
-    let mut flat: Vec<i64> = Vec::new();
-    for inner in values {
-        flat.extend_from_slice(&inner);
-        offsets.push(flat.len() as i32);
-    }
-    let values_arr = Int64Array::from(flat);
-    let field = Arc::new(Field::new("item", DataType::Int64, false));
-    ListArray::new(
-        field,
-        OffsetBuffer::new(offsets.into()),
-        Arc::new(values_arr),
-        None,
-    )
-}
diff --git a/benchmarks-website/migrate/src/migrate/mod.rs b/benchmarks-website/migrate/src/migrate/mod.rs
deleted file mode 100644
index 6c58fe459ed..00000000000
--- a/benchmarks-website/migrate/src/migrate/mod.rs
+++ /dev/null
@@ -1,652 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! End-to-end migration of one v2 dataset into a v3 DuckDB file.
-//!
-//! Streams `data.json.gz` line-by-line, runs each record through the
-//! [`crate::classifier`], and writes one row per record into the appropriate
-//! v3 fact table. Every row's `measurement_id` is computed via the server's
-//! `measurement_id_*` functions so the result is byte-compatible with what
-//! fresh `/api/ingest` would have produced.
-//!
-//! Bulk-load shape: rows are accumulated in memory as parallel column
-//! vectors, deduplicated by `measurement_id`, then flushed to DuckDB
-//! via `Appender::append_record_batch` as one Arrow `RecordBatch` per
-//! fact table.
-
-mod accum;
-
-use std::collections::BTreeMap;
-use std::io::BufRead;
-use std::path::Path;
-use std::time::Duration;
-use std::time::Instant;
-
-use anyhow::Context as _;
-use anyhow::Result;
-use arrow_array::RecordBatch;
-use duckdb::Connection;
-use tracing::info;
-use tracing::warn;
-use vortex_bench_server::db::measurement_id_compression_size;
-use vortex_bench_server::db::measurement_id_compression_time;
-use vortex_bench_server::db::measurement_id_query;
-use vortex_bench_server::db::measurement_id_random_access;
-use vortex_bench_server::family;
-use vortex_bench_server::records::CompressionSize;
-use vortex_bench_server::records::CompressionTime;
-use vortex_bench_server::records::QueryMeasurement;
-use vortex_bench_server::records::RandomAccessTime;
-use vortex_bench_server::schema::COMMITS_DDL;
-
-use self::accum::CompressionSizeAccum;
-use self::accum::CompressionTimeAccum;
-use self::accum::QueryAccum;
-use self::accum::RandomAccessAccum;
-use self::accum::build_compression_size_batch;
-use self::accum::build_compression_time_batch;
-use self::accum::build_query_batch;
-use self::accum::build_random_access_batch;
-use crate::classifier;
-use crate::classifier::V3Bin;
-use crate::commits::upsert_commit;
-use crate::source::KNOWN_FILE_SIZES_SUITES;
-use crate::source::Source;
-use crate::v2::V2Commit;
-use crate::v2::V2FileSize;
-use crate::v2::V2Record;
-use crate::v2::canonical_scale_factor;
-use crate::v2::index_commits;
-use crate::v2::runtime_as_i64;
-use crate::v2::value_as_f64;
-
-/// Per-table insert counts, plus skip / missing counts.
-#[derive(Debug, Default, Clone)]
-pub struct MigrationSummary {
-    /// Lines read from `data.json.gz`.
-    pub records_read: u64,
-    /// Rows successfully inserted into `query_measurements`.
-    pub query_inserted: u64,
-    /// Rows successfully inserted into `compression_times`.
-    pub compression_time_inserted: u64,
-    /// Rows successfully inserted into `compression_sizes`.
-    pub compression_size_inserted: u64,
-    /// Rows successfully inserted into `random_access_times`.
-    pub random_access_inserted: u64,
-    /// `file-sizes-*.json.gz` lines folded into `compression_sizes`.
-    pub file_size_inserted: u64,
-    /// Records the classifier returned `Unknown` for.
-    pub uncategorized: u64,
-    /// Top-level prefix histogram of uncategorised records, for triage.
-    pub uncategorized_prefixes: BTreeMap<String, u64>,
-    /// Records whose `commit_id` doesn't match any commit in `commits.jsonl`.
-    pub missing_commit: u64,
-    /// Warnings emitted while upserting commits (e.g. missing tree SHA).
-    pub commit_warnings: u64,
-    /// Records dropped because their `value` was missing or non-numeric.
-    pub skipped_no_value: u64,
-    /// Records the classifier returned `Skip(reason)` for.
-    pub skipped_intentional: u64,
-    /// Commits upserted into the `commits` dim table.
-    pub commits_inserted: u64,
-    /// Records dropped by dedup because their `measurement_id` collided
-    /// with a previously kept row.
-    pub deduped: u64,
-    /// Number of records dropped by dedup whose `value_ns` (or
-    /// `value_bytes` for compression_sizes' replace path) differed
-    /// from the kept row's. Non-zero is a smell worth investigating.
-    pub deduped_with_conflict: u64,
-    /// `file-sizes-*.json.gz` source files that failed to download /
-    /// decode / parse. Non-zero means the migrated DB has missing
-    /// compression-size history from at least one v2 source file; the
-    /// CLI fails by default in that case unless
-    /// `--allow-missing-file-sizes` is passed.
-    pub file_sizes_failed: u64,
-}
-
-impl MigrationSummary {
-    /// Total `data.json.gz` records that landed in some v3 fact table.
-    pub fn total_inserted(&self) -> u64 {
-        self.query_inserted
-            + self.compression_time_inserted
-            + self.compression_size_inserted
-            + self.random_access_inserted
-    }
-
-    /// Fraction of records that were uncategorized. The orchestrator
-    /// stops if this exceeds the documented 5% threshold.
-    pub fn uncategorized_fraction(&self) -> f64 {
-        if self.records_read == 0 {
-            return 0.0;
-        }
-        self.uncategorized as f64 / self.records_read as f64
-    }
-}
-
-/// Open or create a DuckDB at `path` and apply the v3 schema. The
-/// migrator is a one-shot fresh load; the bulk-append flush is pure
-/// insert (no `ON CONFLICT`), so any stale rows in `path` would clash
-/// with the next run on the same primary keys. Delete both the
-/// database file and its WAL companion up front so every run starts
-/// from a known-empty state.
-pub fn open_target_db(path: &Path) -> Result<Connection> {
-    remove_if_exists(path)?;
-    let wal = wal_path(path);
-    remove_if_exists(&wal)?;
-    let conn =
-        Connection::open(path).with_context(|| format!("opening DuckDB at {}", path.display()))?;
-    // Apply the v3 schema. Drives off the per-fact-table `family::Family`
-    // registry the same way `vortex_bench_server::db::open` does - adding
-    // a sixth fact table only needs a new const there, not an edit here.
-    conn.execute_batch(COMMITS_DDL)
-        .context("applying commits dim DDL")?;
-    for fam in family::FAMILIES {
-        conn.execute_batch(fam.schema_ddl)
-            .with_context(|| format!("applying {} DDL", fam.table_name))?;
-    }
-    Ok(conn)
-}
-
-fn remove_if_exists(path: &Path) -> Result<()> {
-    match std::fs::remove_file(path) {
-        Ok(()) => {
-            info!(path = %path.display(), "removed pre-existing target file");
-            Ok(())
-        }
-        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),
-        Err(e) => Err(e).with_context(|| format!("removing {}", path.display())),
-    }
-}
-
-/// DuckDB writes its write-ahead log next to the database file with a
-/// `.wal` suffix appended (e.g. `v3.duckdb` -> `v3.duckdb.wal`).
-fn wal_path(path: &Path) -> std::path::PathBuf {
-    let mut name = path.as_os_str().to_owned();
-    name.push(".wal");
-    std::path::PathBuf::from(name)
-}
-
-/// Run the whole migration: commits, data.json.gz, and every
-/// file-sizes-*.json.gz under the source.
-pub fn run(source: &Source, target: &Path) -> Result<MigrationSummary> {
-    let mut conn = open_target_db(target)?;
-    let mut summary = MigrationSummary::default();
-
-    info!(source = %source.describe(), "Reading commits.json");
-    let commits = read_commits(source)?;
-    info!(commits = commits.len(), "Loaded commits");
-    summary.commits_inserted = upsert_all_commits(&mut conn, &commits, &mut summary)?;
-
-    let mut q = QueryAccum::default();
-    let mut ct = CompressionTimeAccum::default();
-    let mut cs = CompressionSizeAccum::default();
-    let mut ra = RandomAccessAccum::default();
-
-    info!("Migrating data.json.gz");
-    migrate_data_jsonl(
-        source,
-        &commits,
-        &mut summary,
-        &mut q,
-        &mut ct,
-        &mut cs,
-        &mut ra,
-    )?;
-    info!(records = summary.records_read, "data.json.gz done");
-
-    for name in source.list_file_sizes()? {
-        info!(name = %name, "Migrating file-sizes");
-        if let Err(e) = migrate_file_sizes(source, &name, &commits, &mut summary, &mut cs) {
-            warn!("file-sizes file {name} failed: {e:#}");
-            summary.file_sizes_failed += 1;
-        }
-    }
-
-    info!("Flushing accumulators to DuckDB");
-    flush_all(&conn, q, ct, ra, cs, &mut summary)?;
-
-    Ok(summary)
-}
-
-/// Flush each accumulator's batch and bump the matching per-fact
-/// summary counter only AFTER the flush succeeds. This way a flush
-/// failure leaves the counter at zero (or its previous value) rather
-/// than reporting rows that never landed in DuckDB.
-fn flush_all(
-    conn: &Connection,
-    q: QueryAccum,
-    ct: CompressionTimeAccum,
-    ra: RandomAccessAccum,
-    cs: CompressionSizeAccum,
-    summary: &mut MigrationSummary,
-) -> Result<()> {
-    let batch = build_query_batch(q)?;
-    let n = batch.num_rows() as u64;
-    flush(conn, "query_measurements", batch)?;
-    summary.query_inserted = n;
-
-    let batch = build_compression_time_batch(ct)?;
-    let n = batch.num_rows() as u64;
-    flush(conn, "compression_times", batch)?;
-    summary.compression_time_inserted = n;
-
-    let batch = build_random_access_batch(ra)?;
-    let n = batch.num_rows() as u64;
-    flush(conn, "random_access_times", batch)?;
-    summary.random_access_inserted = n;
-
-    let batch = build_compression_size_batch(cs)?;
-    let n = batch.num_rows() as u64;
-    flush(conn, "compression_sizes", batch)?;
-    summary.compression_size_inserted = n;
-
-    Ok(())
-}
-
-fn read_commits(source: &Source) -> Result<BTreeMap<String, V2Commit>> {
-    let reader = source.open_commits_jsonl()?;
-    let mut commits: Vec<V2Commit> = Vec::new();
-    for line in reader.lines() {
-        let line = line?;
-        let trimmed = line.trim();
-        if trimmed.is_empty() {
-            continue;
-        }
-        match serde_json::from_str::<V2Commit>(trimmed) {
-            Ok(c) => commits.push(c),
-            Err(e) => warn!("skipping malformed commits.json line: {e}"),
-        }
-    }
-    Ok(index_commits(commits))
-}
-
-fn upsert_all_commits(
-    conn: &mut Connection,
-    commits: &BTreeMap<String, V2Commit>,
-    summary: &mut MigrationSummary,
-) -> Result<u64> {
-    let tx = conn.transaction().context("begin commits transaction")?;
-    let mut count = 0u64;
-    for commit in commits.values() {
-        let outcome = upsert_commit(&tx, commit)?;
-        for w in outcome.warnings {
-            warn!("{w}");
-            summary.commit_warnings += 1;
-        }
-        count += 1;
-    }
-    tx.commit().context("commit commits transaction")?;
-    Ok(count)
-}
-
-/// Stream `data.json.gz` and push classified records into the
-/// per-table accumulators. Dedup happens inside each accumulator's
-/// `push` method by `measurement_id`.
-fn migrate_data_jsonl(
-    source: &Source,
-    commits: &BTreeMap<String, V2Commit>,
-    summary: &mut MigrationSummary,
-    q: &mut QueryAccum,
-    ct: &mut CompressionTimeAccum,
-    cs: &mut CompressionSizeAccum,
-    ra: &mut RandomAccessAccum,
-) -> Result<()> {
-    let reader = source.open_data_jsonl()?;
-    let started = Instant::now();
-    let mut last_log = Instant::now();
-    for line in reader.lines() {
-        let line = line?;
-        let trimmed = line.trim();
-        if trimmed.is_empty() {
-            continue;
-        }
-        summary.records_read += 1;
-        let record: V2Record = match serde_json::from_str(trimmed) {
-            Ok(r) => r,
-            Err(e) => {
-                warn!("skipping malformed data.json line: {e}");
-                continue;
-            }
-        };
-        apply_v2_record(&record, commits, summary, q, ct, cs, ra);
-        if last_log.elapsed() >= Duration::from_secs(5) {
-            let elapsed = started.elapsed().as_secs_f64();
-            let rate = summary.records_read as f64 / elapsed.max(0.001);
-            info!(
-                records = summary.records_read,
-                rate = format!("{rate:.0}/s"),
-                query = q.measurement_id.len(),
-                compression_time = ct.measurement_id.len(),
-                compression_size = cs.rows.len(),
-                random_access = ra.measurement_id.len(),
-                "migration progress",
-            );
-            last_log = Instant::now();
-        }
-    }
-    Ok(())
-}
-
-fn apply_v2_record(
-    record: &V2Record,
-    commits: &BTreeMap<String, V2Commit>,
-    summary: &mut MigrationSummary,
-    q: &mut QueryAccum,
-    ct: &mut CompressionTimeAccum,
-    cs: &mut CompressionSizeAccum,
-    ra: &mut RandomAccessAccum,
-) {
-    let Some(sha) = record.commit_id.clone() else {
-        summary.missing_commit += 1;
-        return;
-    };
-    if !commits.contains_key(&sha) {
-        summary.missing_commit += 1;
-        return;
-    }
-
-    let bin = match classifier::classify_outcome(record) {
-        classifier::Outcome::Bin(b) => b,
-        classifier::Outcome::Skip(_) => {
-            summary.skipped_intentional += 1;
-            return;
-        }
-        classifier::Outcome::Unknown => {
-            summary.uncategorized += 1;
-            let prefix = record.name.split('/').next().unwrap_or("").to_string();
-            *summary.uncategorized_prefixes.entry(prefix).or_insert(0) += 1;
-            return;
-        }
-    };
-
-    let env_triple = record.env_triple.as_ref().and_then(|t| t.to_triple());
-    let runtimes = record
-        .all_runtimes
-        .as_ref()
-        .map(|v| v.iter().filter_map(runtime_as_i64).collect::<Vec<i64>>())
-        .unwrap_or_default();
-    let value_f64 = match record.value.as_ref().and_then(value_as_f64) {
-        Some(v) => v,
-        None => {
-            summary.skipped_no_value += 1;
-            return;
-        }
-    };
-
-    match bin {
-        V3Bin::Query {
-            dataset,
-            dataset_variant,
-            scale_factor,
-            query_idx,
-            storage,
-            engine,
-            format,
-        } => {
-            let qm = QueryMeasurement {
-                commit_sha: sha,
-                dataset,
-                dataset_variant,
-                scale_factor,
-                query_idx,
-                storage,
-                engine,
-                format,
-                value_ns: value_f64 as i64,
-                all_runtimes_ns: runtimes,
-                peak_physical: None,
-                peak_virtual: None,
-                physical_delta: None,
-                virtual_delta: None,
-                env_triple,
-            };
-            let mid = measurement_id_query(&qm);
-            q.push(mid, qm, summary);
-        }
-        V3Bin::CompressionTime {
-            dataset,
-            dataset_variant,
-            format,
-            op,
-        } => {
-            let ctr = CompressionTime {
-                commit_sha: sha,
-                dataset,
-                dataset_variant,
-                format,
-                op,
-                value_ns: value_f64 as i64,
-                all_runtimes_ns: runtimes,
-                env_triple,
-            };
-            let mid = measurement_id_compression_time(&ctr);
-            ct.push(mid, ctr, summary);
-        }
-        V3Bin::CompressionSize {
-            dataset,
-            dataset_variant,
-            format,
-        } => {
-            let csr = CompressionSize {
-                commit_sha: sha,
-                dataset,
-                dataset_variant,
-                format,
-                value_bytes: value_f64 as i64,
-            };
-            let mid = measurement_id_compression_size(&csr);
-            cs.push_replace(mid, csr, summary);
-        }
-        V3Bin::RandomAccess { dataset, format } => {
-            let rar = RandomAccessTime {
-                commit_sha: sha,
-                dataset,
-                format,
-                value_ns: value_f64 as i64,
-                all_runtimes_ns: runtimes,
-                env_triple,
-            };
-            let mid = measurement_id_random_access(&rar);
-            ra.push(mid, rar, summary);
-        }
-    }
-}
-
-fn migrate_file_sizes(
-    source: &Source,
-    name: &str,
-    commits: &BTreeMap<String, V2Commit>,
-    summary: &mut MigrationSummary,
-    cs: &mut CompressionSizeAccum,
-) -> Result<()> {
-    let reader = source.open_file_sizes(name)?;
-    // Prefix unknown-id fallbacks with `unknown:` so they're clearly
-    // labeled in the UI rather than masquerading as a dataset name.
-    let dataset_fallback = {
-        let stripped = name
-            .strip_prefix("file-sizes-")
-            .and_then(|s| s.strip_suffix(".json.gz"))
-            .unwrap_or(name);
-        if KNOWN_FILE_SIZES_SUITES.contains(&stripped) {
-            stripped.to_string()
-        } else {
-            format!("unknown:{stripped}")
-        }
-    };
-    let started = Instant::now();
-    let mut last_log = Instant::now();
-    for line in reader.lines() {
-        let line = line?;
-        let trimmed = line.trim();
-        if trimmed.is_empty() {
-            continue;
-        }
-        let sz: V2FileSize = match serde_json::from_str(trimmed) {
-            Ok(r) => r,
-            Err(e) => {
-                warn!("skipping malformed {name} line: {e}");
-                continue;
-            }
-        };
-        if !commits.contains_key(&sz.commit_id) {
-            summary.missing_commit += 1;
-            continue;
-        }
-        let dataset = if sz.benchmark.is_empty() {
-            dataset_fallback.clone()
-        } else {
-            sz.benchmark.clone()
-        };
-        // Run SF through canonical_scale_factor so `"1"`, `"1.0"`, `"10"`
-        // and `"10.0"` collapse to one form, matching what
-        // `bin_compression_size` writes for the data.json.gz path.
-        let dataset_variant = canonical_scale_factor(sz.scale_factor.as_deref());
-        let csr = CompressionSize {
-            commit_sha: sz.commit_id.clone(),
-            dataset,
-            dataset_variant,
-            format: sz.format.clone(),
-            value_bytes: sz.size_bytes,
-        };
-        let mid = measurement_id_compression_size(&csr);
-        cs.push_sum(mid, csr);
-        summary.file_size_inserted += 1;
-        if last_log.elapsed() >= Duration::from_secs(5) {
-            let elapsed = started.elapsed().as_secs_f64();
-            let rate = summary.file_size_inserted as f64 / elapsed.max(0.001);
-            info!(
-                name = %name,
-                file_sizes = summary.file_size_inserted,
-                rate = format!("{rate:.0}/s"),
-                "file-sizes progress",
-            );
-            last_log = Instant::now();
-        }
-    }
-    Ok(())
-}
-
-/// Append an Arrow `RecordBatch` to a DuckDB table via `Appender`.
-fn flush(conn: &Connection, table: &str, batch: RecordBatch) -> Result<()> {
-    let mut app = conn
-        .appender(table)
-        .with_context(|| format!("opening appender for {table}"))?;
-    app.append_record_batch(batch)
-        .with_context(|| format!("appending record batch to {table}"))?;
-    drop(app);
-    Ok(())
-}
-
-/// Print the summary in a human-readable form. Returned by the CLI.
-impl std::fmt::Display for MigrationSummary {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        writeln!(f, "Records read:           {}", self.records_read)?;
-        writeln!(f, "Commits upserted:       {}", self.commits_inserted)?;
-        writeln!(f, "Commit warnings:        {}", self.commit_warnings)?;
-        writeln!(f, "Inserted (query):       {}", self.query_inserted)?;
-        writeln!(
-            f,
-            "Inserted (compress t):  {}",
-            self.compression_time_inserted
-        )?;
-        writeln!(
-            f,
-            "Inserted (compress s):  {}",
-            self.compression_size_inserted
-        )?;
-        writeln!(f, "Inserted (random acc):  {}", self.random_access_inserted)?;
-        writeln!(f, "Inserted (file sizes):  {}", self.file_size_inserted)?;
-        writeln!(f, "Missing commit:         {}", self.missing_commit)?;
-        writeln!(f, "Skipped (no value):     {}", self.skipped_no_value)?;
-        writeln!(f, "Skipped (intentional):  {}", self.skipped_intentional)?;
-        writeln!(f, "Deduplicated:           {}", self.deduped)?;
-        writeln!(f, "Dedup w/ value diff:    {}", self.deduped_with_conflict)?;
-        writeln!(
-            f,
-            "Uncategorized:          {} ({:.2}%)",
-            self.uncategorized,
-            100.0 * self.uncategorized_fraction()
-        )?;
-        if !self.uncategorized_prefixes.is_empty() {
-            let mut top: Vec<_> = self.uncategorized_prefixes.iter().collect();
-            top.sort_by(|a, b| b.1.cmp(a.1));
-            writeln!(f, "Top uncategorized prefixes:")?;
-            for (prefix, n) in top.iter().take(20) {
-                writeln!(f, "  {prefix:>32} : {n}")?;
-            }
-        }
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use vortex_bench_server::records::QueryMeasurement;
-
-    use super::*;
-
-    fn open_db_without(table: &str) -> Result<(tempfile::TempDir, Connection)> {
-        let dir = tempfile::TempDir::new()?;
-        let path = dir.path().join("v3.duckdb");
-        let conn = open_target_db(&path)?;
-        conn.execute_batch(&format!("DROP TABLE {table}"))?;
-        Ok((dir, conn))
-    }
-
-    fn one_query_row() -> QueryMeasurement {
-        QueryMeasurement {
-            commit_sha: "deadbeef".into(),
-            dataset: "clickbench".into(),
-            dataset_variant: None,
-            scale_factor: None,
-            query_idx: 7,
-            storage: "nvme".into(),
-            engine: "datafusion".into(),
-            format: "parquet".into(),
-            value_ns: 100,
-            all_runtimes_ns: vec![100],
-            peak_physical: None,
-            peak_virtual: None,
-            physical_delta: None,
-            virtual_delta: None,
-            env_triple: None,
-        }
-    }
-
-    #[test]
-    fn flush_all_does_not_overcount_on_failure() -> Result<()> {
-        // Drop `compression_times` before flushing so the second
-        // flush in `flush_all` fails. The first (queries) succeeded,
-        // so its counter must be set; the failed table's counter and
-        // every later table's counter must stay at zero.
-        let (_dir, conn) = open_db_without("compression_times")?;
-
-        let mut summary = MigrationSummary::default();
-        let mut q = QueryAccum::default();
-        let qm = one_query_row();
-        let mid = vortex_bench_server::db::measurement_id_query(&qm);
-        q.push(mid, qm, &mut summary);
-
-        let ct = CompressionTimeAccum::default();
-        let ra = RandomAccessAccum::default();
-        let cs = CompressionSizeAccum::default();
-
-        let result = flush_all(&conn, q, ct, ra, cs, &mut summary);
-        assert!(result.is_err(), "expected flush to fail on missing table");
-
-        assert_eq!(
-            summary.query_inserted, 1,
-            "query flushed before the failure must be counted"
-        );
-        assert_eq!(
-            summary.compression_time_inserted, 0,
-            "failed flush must not bump the counter"
-        );
-        assert_eq!(summary.random_access_inserted, 0, "later flushes never ran");
-        assert_eq!(
-            summary.compression_size_inserted, 0,
-            "later flushes never ran"
-        );
-        Ok(())
-    }
-}
diff --git a/benchmarks-website/migrate/src/source.rs b/benchmarks-website/migrate/src/source.rs
deleted file mode 100644
index acd53c7626e..00000000000
--- a/benchmarks-website/migrate/src/source.rs
+++ /dev/null
@@ -1,140 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Streaming readers for v2's public S3 bucket.
-//!
-//! The bucket is `--no-sign-request`, so we fetch the underlying
-//! HTTPS URL directly and stream-decompress with `flate2`. The
-//! downloads are wrapped in [`reqwest::blocking`] to keep the read
-//! path synchronous; the binary's hot path is single-threaded
-//! per-source already (DuckDB is a single-writer).
-//!
-//! For tests and offline runs, [`Source::Local`](crate::source::Source::Local) accepts a local
-//! directory of dumps; the migrator's `--source` flag picks the
-//! variant.
-
-use std::fs::File;
-use std::io::BufRead;
-use std::io::BufReader;
-use std::io::Read;
-use std::path::Path;
-use std::path::PathBuf;
-
-use anyhow::Context as _;
-use anyhow::Result;
-use flate2::read::GzDecoder;
-use tracing::info;
-
-/// Public S3 bucket the live v2 server reads from.
-pub const PUBLIC_BUCKET_BASE: &str = "https://vortex-ci-benchmark-results.s3.amazonaws.com";
-
-/// Where to read the v2 dataset from. Either the public S3 bucket
-/// (the live deployment) or a local directory of dumps.
-#[derive(Debug, Clone)]
-pub enum Source {
-    /// HTTPS GETs against `s3.amazonaws.com`.
-    PublicS3,
-    /// A directory containing `data.json.gz`, `commits.json`, and
-    /// `file-sizes-*.json.gz` files.
-    Local(PathBuf),
-}
-
-impl Source {
-    /// Short human-readable description for log messages.
-    pub fn describe(&self) -> String {
-        match self {
-            Source::PublicS3 => "public S3 bucket".to_string(),
-            Source::Local(p) => format!("local dir {}", p.display()),
-        }
-    }
-
-    /// Open `data.json.gz` for streaming, decompressing on the fly.
-    pub fn open_data_jsonl(&self) -> Result<Box<dyn BufRead>> {
-        let stream = self.open_raw("data.json.gz")?;
-        Ok(Box::new(BufReader::new(GzDecoder::new(stream))))
-    }
-
-    /// Open `commits.json` (uncompressed).
-    pub fn open_commits_jsonl(&self) -> Result<Box<dyn BufRead>> {
-        let stream = self.open_raw("commits.json")?;
-        Ok(Box::new(BufReader::new(stream)))
-    }
-
-    /// Enumerate `file-sizes-*.json.gz` files. For local sources this
-    /// is a directory glob; for the public bucket we hit the documented
-    /// suite ids.
-    pub fn list_file_sizes(&self) -> Result<Vec<String>> {
-        match self {
-            Source::Local(dir) => {
-                let mut out = Vec::new();
-                for entry in std::fs::read_dir(dir)? {
-                    let entry = entry?;
-                    let name = entry.file_name();
-                    let s = name.to_string_lossy();
-                    if s.starts_with("file-sizes-") && s.ends_with(".json.gz") {
-                        out.push(s.into_owned());
-                    }
-                }
-                out.sort();
-                Ok(out)
-            }
-            Source::PublicS3 => {
-                // The S3 bucket's ListObjects is denied for unsigned
-                // requests, so we hit the documented per-suite keys
-                // emitted by `.github/workflows/sql-benchmarks.yml`.
-                Ok(KNOWN_FILE_SIZES_SUITES
-                    .iter()
-                    .map(|id| format!("file-sizes-{id}.json.gz"))
-                    .collect())
-            }
-        }
-    }
-
-    /// Open one `file-sizes-*.json.gz` for streaming.
-    pub fn open_file_sizes(&self, name: &str) -> Result<Box<dyn BufRead>> {
-        let stream = self.open_raw(name)?;
-        Ok(Box::new(BufReader::new(GzDecoder::new(stream))))
-    }
-
-    fn open_raw(&self, name: &str) -> Result<Box<dyn Read + Send>> {
-        match self {
-            Source::Local(dir) => open_local(&dir.join(name)),
-            Source::PublicS3 => open_s3(name),
-        }
-    }
-}
-
-fn open_local(path: &Path) -> Result<Box<dyn Read + Send>> {
-    let f = File::open(path).with_context(|| format!("opening {}", path.display()))?;
-    Ok(Box::new(f))
-}
-
-fn open_s3(name: &str) -> Result<Box<dyn Read + Send>> {
-    let url = format!("{PUBLIC_BUCKET_BASE}/{name}");
-    info!(url = %url, "GET");
-    let resp = reqwest::blocking::get(&url).with_context(|| format!("GET {url}"))?;
-    if !resp.status().is_success() {
-        anyhow::bail!("GET {url} returned {}", resp.status());
-    }
-    Ok(Box::new(resp))
-}
-
-/// Suite IDs we know publish a `file-sizes-{id}.json.gz` to S3.
-///
-/// Source of truth: the `matrix.id` values in
-/// `.github/workflows/sql-benchmarks.yml`'s `benchmark_matrix` default.
-/// The post-bench `file-sizes` step uploads `file-sizes-${{ matrix.id
-/// }}.json.gz`, so this list must match those IDs verbatim. Adding a
-/// new matrix entry to that workflow means adding the same ID here.
-pub(crate) const KNOWN_FILE_SIZES_SUITES: &[&str] = &[
-    "clickbench-nvme",
-    "tpch-nvme",
-    "tpch-s3",
-    "tpch-nvme-10",
-    "tpch-s3-10",
-    "tpcds-nvme",
-    "statpopgen",
-    "fineweb",
-    "fineweb-s3",
-    "polarsignals",
-];
diff --git a/benchmarks-website/migrate/src/v2.rs b/benchmarks-website/migrate/src/v2.rs
deleted file mode 100644
index 79785ba1fd4..00000000000
--- a/benchmarks-website/migrate/src/v2.rs
+++ /dev/null
@@ -1,197 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Wire shapes of the v2 benchmark dataset on S3.
-//!
-//! These types capture only the fields the migrator reads. v2 records
-//! are serialized by `vortex-bench` (see `vortex-bench/src/measurements.rs`)
-//! and by older non-Rust scripts; the union of fields is loose, so we
-//! deserialize permissively (`serde(default)`, untyped `serde_json::Value`
-//! for the polymorphic `dataset` field).
-
-use std::collections::BTreeMap;
-
-use serde::Deserialize;
-
-/// One JSONL line of `data.json.gz`.
-///
-/// The shape is the union of every emitter's output. Most fields are
-/// optional because different benches emit different subsets.
-#[derive(Debug, Clone, Deserialize)]
-pub struct V2Record {
-    /// Slash-separated benchmark identifier (e.g. `tpch_q01/datafusion:vortex-file-compressed`).
-    /// The classifier parses this string to recover dim values.
-    pub name: String,
-    /// 40-hex commit SHA. Present on every well-formed v2 record.
-    #[serde(default)]
-    pub commit_id: Option<String>,
-    /// v2 unit string (`ns`, `bytes`, `ratio`, ...). Not used for routing —
-    /// the classifier picks the v3 fact table from the `name` prefix instead.
-    #[serde(default)]
-    pub unit: Option<String>,
-    /// Polymorphic value — emitters wrote both numbers and stringified
-    /// numbers. Use [`value_as_f64`] to normalize.
-    #[serde(default)]
-    pub value: Option<serde_json::Value>,
-    /// Storage backend the run targeted (`S3` or `NVMe`, mixed case in v2).
-    #[serde(default)]
-    pub storage: Option<String>,
-    /// Polymorphic dataset block — sometimes a string, sometimes an object
-    /// keyed by suite name with a `scale_factor` inside (use
-    /// [`dataset_scale_factor`]).
-    #[serde(default)]
-    pub dataset: Option<serde_json::Value>,
-    /// Per-iteration runtimes; same numeric polymorphism as `value`.
-    #[serde(default)]
-    pub all_runtimes: Option<Vec<serde_json::Value>>,
-    /// Host environment triple block.
-    #[serde(default)]
-    pub env_triple: Option<V2EnvTriple>,
-}
-
-/// `dataset` in v2 records is sometimes a string, sometimes an object
-/// keyed by suite name (`{ "tpch": { "scale_factor": "10" } }`).
-/// This helper looks up the scale factor for a given suite without
-/// assuming a particular shape.
-pub fn dataset_scale_factor(dataset: &serde_json::Value, key: &str) -> Option<String> {
-    let obj = dataset.as_object()?;
-    let entry = obj.get(key)?;
-    let sf = entry.get("scale_factor")?;
-    match sf {
-        serde_json::Value::String(s) => Some(s.clone()),
-        serde_json::Value::Number(n) => Some(n.to_string()),
-        _ => None,
-    }
-}
-
-/// Canonicalize a v2 scale-factor string for use in `dataset_variant`.
-///
-/// v2 emitters wrote scale factors as either `"1"`, `"1.0"`, `"10"`, or
-/// `"10.0"` for the same logical SF, so the data.json.gz path
-/// (`bin_compression_size`) and the file-sizes-*.json.gz path
-/// (`migrate_file_sizes`) would otherwise produce different
-/// `dataset_variant` strings and never collapse onto the same
-/// `measurement_id`. Parse to f64 and format with no trailing zeros so
-/// every shape collapses to one canonical form (`"1"`, `"10"`, `"0.1"`).
-/// SF=1 is the implicit default and folds to `None`.
-pub fn canonical_scale_factor(raw: Option<&str>) -> Option<String> {
-    let s = raw?.trim();
-    if s.is_empty() {
-        return None;
-    }
-    let value: f64 = s.parse().ok()?;
-    if value == 1.0 {
-        return None;
-    }
-    Some(format!("{value}"))
-}
-
-/// Best-effort numeric coercion for the polymorphic `value` field.
-pub fn value_as_f64(value: &serde_json::Value) -> Option<f64> {
-    match value {
-        serde_json::Value::Number(n) => n.as_f64(),
-        serde_json::Value::String(s) => s.parse().ok(),
-        _ => None,
-    }
-}
-
-/// Best-effort coercion of a runtime entry to nanoseconds.
-pub fn runtime_as_i64(value: &serde_json::Value) -> Option<i64> {
-    match value {
-        serde_json::Value::Number(n) => {
-            if let Some(i) = n.as_i64() {
-                Some(i)
-            } else {
-                n.as_f64().map(|f| f as i64)
-            }
-        }
-        serde_json::Value::String(s) => s.parse().ok(),
-        _ => None,
-    }
-}
-
-/// Triple block as emitted by `vortex-bench`'s `--gh-json` path. v2
-/// stored it as an object; we serialize it back out as `arch-os-env`.
-#[derive(Debug, Clone, Deserialize)]
-pub struct V2EnvTriple {
-    /// Host CPU architecture (e.g. `x86_64`).
-    #[serde(default)]
-    pub architecture: Option<String>,
-    /// Operating system name (e.g. `linux`).
-    #[serde(default)]
-    pub operating_system: Option<String>,
-    /// Host environment label (e.g. `gnu`).
-    #[serde(default)]
-    pub environment: Option<String>,
-}
-
-impl V2EnvTriple {
-    /// Format as the `arch-os-env` triple used by v3's `env_triple` column.
-    pub fn to_triple(&self) -> Option<String> {
-        let arch = self.architecture.as_deref()?;
-        let os = self.operating_system.as_deref()?;
-        let env = self.environment.as_deref()?;
-        Some(format!("{arch}-{os}-{env}"))
-    }
-}
-
-/// One JSONL line of `commits.json`.
-#[derive(Debug, Clone, Deserialize)]
-pub struct V2Commit {
-    /// 40-hex commit SHA (the v2 schema named this `id`, not `commit_sha`).
-    pub id: String,
-    /// RFC 3339 commit timestamp; required for the v3 row but tolerated as
-    /// missing in the source dump.
-    #[serde(default)]
-    pub timestamp: Option<String>,
-    /// Full commit message.
-    #[serde(default)]
-    pub message: Option<String>,
-    /// Author block.
-    #[serde(default)]
-    pub author: Option<V2Person>,
-    /// Committer block.
-    #[serde(default)]
-    pub committer: Option<V2Person>,
-    /// Git tree SHA.
-    #[serde(default)]
-    pub tree_id: Option<String>,
-    /// GitHub commit URL.
-    #[serde(default)]
-    pub url: Option<String>,
-}
-
-/// Author or committer block on a v2 commit record.
-#[derive(Debug, Clone, Deserialize)]
-pub struct V2Person {
-    /// Display name.
-    #[serde(default)]
-    pub name: Option<String>,
-    /// Email address.
-    #[serde(default)]
-    pub email: Option<String>,
-}
-
-/// One JSONL line of `file-sizes-*.json.gz` produced by
-/// `scripts/capture-file-sizes.py`.
-#[derive(Debug, Clone, Deserialize)]
-pub struct V2FileSize {
-    /// 40-hex commit SHA.
-    pub commit_id: String,
-    /// Compression dataset name (`benchmark` is the v2 field name).
-    pub benchmark: String,
-    /// TPC SF as a string when relevant.
-    #[serde(default)]
-    pub scale_factor: Option<String>,
-    /// Format the file was produced in.
-    pub format: String,
-    /// Path of the underlying file (e.g. `lineitem.parquet`); informational.
-    pub file: String,
-    /// Size in bytes; summed across files in the same `(commit, dataset, format)`.
-    pub size_bytes: i64,
-}
-
-/// Build a sha-keyed map of commits.
-pub fn index_commits(commits: Vec<V2Commit>) -> BTreeMap<String, V2Commit> {
-    commits.into_iter().map(|c| (c.id.clone(), c)).collect()
-}
diff --git a/benchmarks-website/migrate/src/verify.rs b/benchmarks-website/migrate/src/verify.rs
deleted file mode 100644
index c855904a5a5..00000000000
--- a/benchmarks-website/migrate/src/verify.rs
+++ /dev/null
@@ -1,360 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Structural diff between a migrated v3 DuckDB and the live v2
-//! `/api/metadata` endpoint.
-//!
-//! Compares group / chart structure only; values aren't compared
-//! because v2 converts ns → ms and bytes → MiB on read while v3
-//! stores raw and the chart query divides. Group/chart structural
-//! equivalence is enough to spot classifier regressions before
-//! cutover.
-
-use std::collections::BTreeMap;
-use std::collections::BTreeSet;
-use std::path::Path;
-
-use anyhow::Context as _;
-use anyhow::Result;
-use duckdb::Connection;
-use serde::Deserialize;
-
-use crate::classifier::QUERY_SUITES;
-
-/// Result of one `verify` run.
-#[derive(Debug, Default)]
-pub struct VerifyReport {
-    /// Group display names present in both v2 and v3.
-    pub matched_groups: Vec<String>,
-    /// Group display names that exist in v3 but not v2.
-    pub only_in_v3: Vec<String>,
-    /// Group display names that exist in v2 but not v3 — these gate the CLI's
-    /// non-zero exit.
-    pub only_in_v2: Vec<String>,
-    /// Per-group chart-count diffs for groups present on both sides.
-    pub chart_diffs: Vec<ChartDiff>,
-}
-
-/// One group's chart-count divergence between v2 and v3, captured when the
-/// group is structurally present on both sides but the counts differ.
-#[derive(Debug, Clone)]
-pub struct ChartDiff {
-    /// Group display name.
-    pub group: String,
-    /// Number of charts v2 reported for this group.
-    pub v2_count: usize,
-    /// Number of charts the migrated v3 DuckDB has for this group.
-    pub v3_count: usize,
-}
-
-impl VerifyReport {
-    /// True if every v2 group is represented in v3. The CLI's exit
-    /// code reflects this.
-    pub fn v2_groups_covered(&self) -> bool {
-        self.only_in_v2.is_empty()
-    }
-}
-
-impl std::fmt::Display for VerifyReport {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        writeln!(f, "Groups in both v2 and v3:")?;
-        for g in &self.matched_groups {
-            writeln!(f, "  + {g}")?;
-        }
-        if !self.only_in_v2.is_empty() {
-            writeln!(f, "Groups only in v2 (regression candidates):")?;
-            for g in &self.only_in_v2 {
-                writeln!(f, "  - {g}")?;
-            }
-        }
-        if !self.only_in_v3.is_empty() {
-            writeln!(f, "Groups only in v3:")?;
-            for g in &self.only_in_v3 {
-                writeln!(f, "  + {g}")?;
-            }
-        }
-        if !self.chart_diffs.is_empty() {
-            writeln!(f, "Chart count diffs:")?;
-            for d in &self.chart_diffs {
-                writeln!(
-                    f,
-                    "  {} : v2={} v3={} (delta={})",
-                    d.group,
-                    d.v2_count,
-                    d.v3_count,
-                    d.v3_count as i64 - d.v2_count as i64,
-                )?;
-            }
-        }
-        Ok(())
-    }
-}
-
-/// v2's `/api/metadata` reply — only the fields we need.
-#[derive(Debug, Deserialize)]
-struct V2Metadata {
-    groups: BTreeMap<String, V2GroupMeta>,
-}
-
-#[derive(Debug, Deserialize)]
-struct V2GroupMeta {
-    #[serde(default)]
-    charts: Vec<V2ChartMeta>,
-}
-
-#[derive(Debug, Deserialize)]
-struct V2ChartMeta {
-    #[serde(default)]
-    name: String,
-}
-
-/// Open the migrated DuckDB at `duckdb_path`, fetch `<v2_server>/api/metadata`,
-/// and produce a structural diff.
-pub fn run(v2_server: &str, duckdb_path: &Path) -> Result<VerifyReport> {
-    let v3 = collect_v3_groups(duckdb_path)?;
-    let v2 = fetch_v2_metadata(v2_server)?;
-    Ok(diff(&v2, &v3))
-}
-
-fn collect_v3_groups(duckdb_path: &Path) -> Result<BTreeMap<String, BTreeSet<String>>> {
-    let conn = Connection::open(duckdb_path)
-        .with_context(|| format!("opening DuckDB at {}", duckdb_path.display()))?;
-    let mut groups: BTreeMap<String, BTreeSet<String>> = BTreeMap::new();
-
-    // query_measurements: chart per (dataset, query_idx); group per
-    // (dataset, dataset_variant, scale_factor, storage). We want v2
-    // group display names so the verifier can compare apples to
-    // apples, so we re-format them here using the same suite table.
-    let mut stmt = conn.prepare(
-        r#"
-        SELECT dataset, dataset_variant, scale_factor, storage, query_idx
-          FROM query_measurements
-         GROUP BY dataset, dataset_variant, scale_factor, storage, query_idx
-        "#,
-    )?;
-    let rows = stmt.query_map([], |row| {
-        Ok((
-            row.get::<_, String>(0)?,
-            row.get::<_, Option<String>>(1)?,
-            row.get::<_, Option<String>>(2)?,
-            row.get::<_, String>(3)?,
-            row.get::<_, i32>(4)?,
-        ))
-    })?;
-    for row in rows {
-        let (dataset, _variant, sf, storage, query_idx) = row?;
-        let group_name = display_query_group(&dataset, sf.as_deref(), &storage);
-        let chart_name = chart_name_query(&dataset, query_idx);
-        groups
-            .entry(group_name)
-            .or_default()
-            .insert(normalize_chart(&chart_name));
-    }
-
-    // compression_times: group "Compression", charts per dataset.
-    let mut stmt = conn.prepare(
-        r#"
-        SELECT dataset, format, op
-          FROM compression_times
-         GROUP BY dataset, format, op
-        "#,
-    )?;
-    let rows = stmt.query_map([], |row| {
-        Ok((
-            row.get::<_, String>(0)?,
-            row.get::<_, String>(1)?,
-            row.get::<_, String>(2)?,
-        ))
-    })?;
-    for row in rows {
-        let (dataset, format, op) = row?;
-        let chart = chart_name_compression_time(&format, &op, &dataset);
-        groups
-            .entry("Compression".to_string())
-            .or_default()
-            .insert(normalize_chart(&chart));
-    }
-
-    let mut stmt = conn.prepare(
-        r#"
-        SELECT dataset, format
-          FROM compression_sizes
-         GROUP BY dataset, format
-        "#,
-    )?;
-    let rows = stmt.query_map([], |row| {
-        Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
-    })?;
-    for row in rows {
-        let (_dataset, format) = row?;
-        let chart = chart_name_compression_size(&format);
-        groups
-            .entry("Compression Size".to_string())
-            .or_default()
-            .insert(normalize_chart(&chart));
-    }
-
-    let mut stmt = conn.prepare(
-        r#"
-        SELECT DISTINCT dataset
-          FROM random_access_times
-        "#,
-    )?;
-    let rows = stmt.query_map([], |row| row.get::<_, String>(0))?;
-    for row in rows {
-        let dataset = row?;
-        groups
-            .entry("Random Access".to_string())
-            .or_default()
-            .insert(normalize_chart(&dataset));
-    }
-
-    Ok(groups)
-}
-
-fn fetch_v2_metadata(server: &str) -> Result<BTreeMap<String, BTreeSet<String>>> {
-    let url = format!("{}/api/metadata", server.trim_end_matches('/'));
-    let body = reqwest::blocking::get(&url)
-        .with_context(|| format!("GET {url}"))?
-        .error_for_status()
-        .with_context(|| format!("non-2xx from {url}"))?
-        .json::<V2Metadata>()
-        .with_context(|| format!("parsing {url} as v2 /api/metadata"))?;
-    let mut out: BTreeMap<String, BTreeSet<String>> = BTreeMap::new();
-    for (name, group) in body.groups {
-        let charts = group
-            .charts
-            .into_iter()
-            .map(|c| normalize_chart(&c.name))
-            .collect();
-        out.insert(name, charts);
-    }
-    Ok(out)
-}
-
-fn diff(
-    v2: &BTreeMap<String, BTreeSet<String>>,
-    v3: &BTreeMap<String, BTreeSet<String>>,
-) -> VerifyReport {
-    let mut report = VerifyReport::default();
-    let v2_keys: BTreeSet<&String> = v2.keys().collect();
-    let v3_keys: BTreeSet<&String> = v3.keys().collect();
-    for g in v2_keys.intersection(&v3_keys) {
-        report.matched_groups.push((**g).clone());
-        let v2_charts = &v2[*g];
-        let v3_charts = &v3[*g];
-        if v2_charts.len() != v3_charts.len() {
-            report.chart_diffs.push(ChartDiff {
-                group: (**g).clone(),
-                v2_count: v2_charts.len(),
-                v3_count: v3_charts.len(),
-            });
-        }
-    }
-    for g in v3_keys.difference(&v2_keys) {
-        report.only_in_v3.push((**g).clone());
-    }
-    for g in v2_keys.difference(&v3_keys) {
-        report.only_in_v2.push((**g).clone());
-    }
-    report.matched_groups.sort();
-    report.only_in_v3.sort();
-    report.only_in_v2.sort();
-    report
-}
-
-fn display_query_group(dataset: &str, scale_factor: Option<&str>, storage: &str) -> String {
-    let suite = QUERY_SUITES
-        .iter()
-        .find(|s| s.prefix.eq_ignore_ascii_case(dataset))
-        .copied();
-    match suite {
-        Some(suite) if suite.fan_out => {
-            let storage_disp = match storage {
-                "s3" | "S3" => "S3",
-                _ => "NVMe",
-            };
-            let sf = scale_factor.unwrap_or("1");
-            format!("{} ({}) (SF={})", suite.display_name, storage_disp, sf)
-        }
-        Some(suite) => suite.display_name.to_string(),
-        None => format!("{dataset} ({storage})"),
-    }
-}
-
-fn chart_name_query(dataset: &str, query_idx: i32) -> String {
-    let suite = QUERY_SUITES
-        .iter()
-        .find(|s| s.prefix.eq_ignore_ascii_case(dataset))
-        .copied();
-    match suite {
-        Some(suite) => format!("{} Q{}", suite.query_prefix, query_idx),
-        None => format!("{} Q{}", dataset.to_uppercase(), query_idx),
-    }
-}
-
-fn chart_name_compression_time(format: &str, op: &str, _dataset: &str) -> String {
-    // Re-derive the v2 chart name (the metric, not the dataset) so we
-    // can compare. v2's chart axis is the metric; series is the
-    // dataset. v3 inverts that. For structural comparison, we project
-    // back to v2's per-chart key.
-    match (format, op) {
-        ("vortex-file-compressed", "encode") => "COMPRESS TIME".into(),
-        ("vortex-file-compressed", "decode") => "DECOMPRESS TIME".into(),
-        ("parquet", "encode") => "PARQUET RS ZSTD COMPRESS TIME".into(),
-        ("parquet", "decode") => "PARQUET RS ZSTD DECOMPRESS TIME".into(),
-        ("lance", "encode") => "LANCE COMPRESS TIME".into(),
-        ("lance", "decode") => "LANCE DECOMPRESS TIME".into(),
-        _ => format!("{} {} TIME", format.to_uppercase(), op.to_uppercase()),
-    }
-}
-
-fn chart_name_compression_size(format: &str) -> String {
-    match format {
-        "vortex-file-compressed" => "VORTEX SIZE".into(),
-        "parquet" => "PARQUET SIZE".into(),
-        "lance" => "LANCE SIZE".into(),
-        _ => format!("{} SIZE", format.to_uppercase()),
-    }
-}
-
-/// Strip casing and `_-` differences between v2 and v3 chart names.
-/// v2 displays uppercase; v3 stores raw values. Comparing in this
-/// canonical form is enough for structural verification.
-fn normalize_chart(s: &str) -> String {
-    s.trim()
-        .to_uppercase()
-        .replace(['_', '-'], " ")
-        .split_whitespace()
-        .collect::<Vec<_>>()
-        .join(" ")
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn normalize_chart_canonicalizes() {
-        assert_eq!(normalize_chart("taxi/take"), "TAXI/TAKE");
-        assert_eq!(normalize_chart("TAXI/TAKE"), "TAXI/TAKE");
-        assert_eq!(normalize_chart("tpc-h q1"), "TPC H Q1");
-        assert_eq!(normalize_chart("tpc h q1"), "TPC H Q1");
-    }
-
-    #[test]
-    fn display_query_group_handles_fan_out() {
-        assert_eq!(
-            display_query_group("tpch", Some("10"), "s3"),
-            "TPC-H (S3) (SF=10)"
-        );
-        assert_eq!(
-            display_query_group("tpch", Some("100"), "nvme"),
-            "TPC-H (NVMe) (SF=100)"
-        );
-        assert_eq!(
-            display_query_group("clickbench", None, "nvme"),
-            "Clickbench"
-        );
-    }
-}
diff --git a/benchmarks-website/migrate/tests/classifier.rs b/benchmarks-website/migrate/tests/classifier.rs
deleted file mode 100644
index 71e97cb6c9a..00000000000
--- a/benchmarks-website/migrate/tests/classifier.rs
+++ /dev/null
@@ -1,531 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Classifier behavior pinned by representative v2 names from each
-//! group in `benchmarks-website/server.js`'s `getGroup`.
-
-use rstest::rstest;
-use serde_json::json;
-use vortex_bench_migrate::classifier::Outcome;
-use vortex_bench_migrate::classifier::Skip;
-use vortex_bench_migrate::classifier::V3Bin;
-use vortex_bench_migrate::classifier::classify;
-use vortex_bench_migrate::classifier::classify_outcome;
-use vortex_bench_migrate::classifier::format_query;
-use vortex_bench_migrate::classifier::rename_engine;
-use vortex_bench_migrate::v2::V2Record;
-
-fn record(name: &str) -> V2Record {
-    V2Record {
-        name: name.to_string(),
-        commit_id: Some("deadbeef".into()),
-        unit: Some("ns".into()),
-        value: Some(json!(123)),
-        storage: None,
-        dataset: None,
-        all_runtimes: None,
-        env_triple: None,
-    }
-}
-
-fn record_with_storage_and_sf(name: &str, storage: &str, suite: &str, sf: &str) -> V2Record {
-    let mut r = record(name);
-    r.storage = Some(storage.into());
-    r.dataset = Some(json!({ suite: { "scale_factor": sf } }));
-    r
-}
-
-#[rstest]
-#[case::clickbench(
-    "clickbench_q07/datafusion:parquet",
-    V3Bin::Query {
-        dataset: "clickbench".into(),
-        dataset_variant: None,
-        scale_factor: None,
-        query_idx: 7,
-        storage: "nvme".into(),
-        engine: "datafusion".into(),
-        format: "parquet".into(),
-    },
-)]
-#[case::clickbench_vortex_renamed(
-    "clickbench_q12/datafusion:vortex-file-compressed",
-    V3Bin::Query {
-        dataset: "clickbench".into(),
-        dataset_variant: None,
-        scale_factor: None,
-        query_idx: 12,
-        storage: "nvme".into(),
-        engine: "datafusion".into(),
-        format: "vortex-file-compressed".into(),
-    },
-)]
-#[case::statpopgen(
-    "statpopgen_q3/datafusion:parquet",
-    V3Bin::Query {
-        dataset: "statpopgen".into(),
-        dataset_variant: None,
-        scale_factor: None,
-        query_idx: 3,
-        storage: "nvme".into(),
-        engine: "datafusion".into(),
-        format: "parquet".into(),
-    },
-)]
-#[case::polarsignals(
-    "polarsignals_q1/duckdb:parquet",
-    V3Bin::Query {
-        dataset: "polarsignals".into(),
-        dataset_variant: None,
-        scale_factor: None,
-        query_idx: 1,
-        storage: "nvme".into(),
-        engine: "duckdb".into(),
-        format: "parquet".into(),
-    },
-)]
-fn non_fan_out_query_records(#[case] name: &str, #[case] expected: V3Bin) {
-    let r = record(name);
-    assert_eq!(classify(&r), Some(expected));
-}
-
-#[rstest]
-#[case::tpch_s3_sf100(
-    "tpch_q01/datafusion:parquet",
-    "S3",
-    "tpch",
-    "100",
-    V3Bin::Query {
-        dataset: "tpch".into(),
-        dataset_variant: None,
-        scale_factor: Some("100".into()),
-        query_idx: 1,
-        storage: "s3".into(),
-        engine: "datafusion".into(),
-        format: "parquet".into(),
-    },
-)]
-#[case::tpch_nvme_sf1(
-    "tpch_q22/duckdb:vortex-file-compressed",
-    "NVMe",
-    "tpch",
-    "1",
-    V3Bin::Query {
-        dataset: "tpch".into(),
-        dataset_variant: None,
-        scale_factor: Some("1".into()),
-        query_idx: 22,
-        storage: "nvme".into(),
-        engine: "duckdb".into(),
-        format: "vortex-file-compressed".into(),
-    },
-)]
-#[case::tpcds_nvme_sf10(
-    "tpcds_q05/datafusion:vortex-file-compressed",
-    "NVMe",
-    "tpcds",
-    "10",
-    V3Bin::Query {
-        dataset: "tpcds".into(),
-        dataset_variant: None,
-        scale_factor: Some("10".into()),
-        query_idx: 5,
-        storage: "nvme".into(),
-        engine: "datafusion".into(),
-        format: "vortex-file-compressed".into(),
-    },
-)]
-fn fan_out_query_records(
-    #[case] name: &str,
-    #[case] storage: &str,
-    #[case] suite: &str,
-    #[case] sf: &str,
-    #[case] expected: V3Bin,
-) {
-    let r = record_with_storage_and_sf(name, storage, suite, sf);
-    assert_eq!(classify(&r), Some(expected));
-}
-
-#[rstest]
-#[case::random_access_4_part(
-    "random-access/taxi/take/parquet-tokio-local-disk",
-    V3Bin::RandomAccess {
-        dataset: "taxi/take".into(),
-        format: "parquet".into(),
-    },
-)]
-#[case::random_access_4_part_vortex(
-    "random-access/chimp/take/vortex-tokio-local-disk",
-    V3Bin::RandomAccess {
-        dataset: "chimp/take".into(),
-        format: "vortex-file-compressed".into(),
-    },
-)]
-#[case::random_access_4_part_lance(
-    "random-access/taxi/take/lance-tokio-local-disk",
-    V3Bin::RandomAccess {
-        dataset: "taxi/take".into(),
-        format: "lance".into(),
-    },
-)]
-fn random_access_records(#[case] name: &str, #[case] expected: V3Bin) {
-    let r = record(name);
-    assert_eq!(classify(&r), Some(expected));
-}
-
-#[rstest]
-#[case::compress_time_vortex(
-    "compress time/clickbench",
-    V3Bin::CompressionTime {
-        dataset: "clickbench".into(),
-        dataset_variant: None,
-        format: "vortex-file-compressed".into(),
-        op: "encode".into(),
-    },
-)]
-#[case::decompress_time_vortex(
-    "decompress time/tpch_lineitem",
-    V3Bin::CompressionTime {
-        dataset: "tpch_lineitem".into(),
-        dataset_variant: None,
-        format: "vortex-file-compressed".into(),
-        op: "decode".into(),
-    },
-)]
-#[case::parquet_compress(
-    "parquet_rs-zstd compress time/clickbench",
-    V3Bin::CompressionTime {
-        dataset: "clickbench".into(),
-        dataset_variant: None,
-        format: "parquet".into(),
-        op: "encode".into(),
-    },
-)]
-#[case::lance_decompress(
-    "lance decompress time/clickbench",
-    V3Bin::CompressionTime {
-        dataset: "clickbench".into(),
-        dataset_variant: None,
-        format: "lance".into(),
-        op: "decode".into(),
-    },
-)]
-fn compression_time_records(#[case] name: &str, #[case] expected: V3Bin) {
-    let r = record(name);
-    assert_eq!(classify(&r), Some(expected));
-}
-
-#[rstest]
-#[case::vortex_size(
-    "vortex size/clickbench",
-    V3Bin::CompressionSize {
-        dataset: "clickbench".into(),
-        dataset_variant: None,
-        format: "vortex-file-compressed".into(),
-    },
-)]
-#[case::vortex_file_compressed_size_normalizes(
-    "vortex-file-compressed size/clickbench",
-    V3Bin::CompressionSize {
-        dataset: "clickbench".into(),
-        dataset_variant: None,
-        format: "vortex-file-compressed".into(),
-    },
-)]
-#[case::parquet_size(
-    "parquet size/clickbench",
-    V3Bin::CompressionSize {
-        dataset: "clickbench".into(),
-        dataset_variant: None,
-        format: "parquet".into(),
-    },
-)]
-#[case::lance_size(
-    "lance size/tpch_lineitem",
-    V3Bin::CompressionSize {
-        dataset: "tpch_lineitem".into(),
-        dataset_variant: None,
-        format: "lance".into(),
-    },
-)]
-fn compression_size_records(#[case] name: &str, #[case] expected: V3Bin) {
-    let r = record(name);
-    assert_eq!(classify(&r), Some(expected));
-}
-
-#[rstest]
-#[case::ratio_vortex_parquet("vortex:parquet-zstd ratio compress time/clickbench")]
-#[case::ratio_vortex_lance("vortex:lance ratio decompress time/clickbench")]
-#[case::ratio_size_vortex_parquet("vortex:parquet-zstd size/clickbench")]
-#[case::ratio_size_vortex_raw("vortex:raw size/clickbench")]
-#[case::throughput("compress throughput/clickbench")]
-#[case::nonsense_prefix("not-a-known-bench/series")]
-#[case::random_access_3_part("random-access/taxi/parquet-tokio-local-disk")]
-fn unmapped_records_yield_none(#[case] name: &str) {
-    let r = record(name);
-    assert_eq!(
-        classify(&r),
-        None,
-        "expected {name:?} to classify as None (drop)",
-    );
-}
-
-#[rstest]
-#[case::parquet_2_part(
-    "random-access/parquet-tokio-local-disk",
-    V3Bin::RandomAccess {
-        dataset: "taxi".into(),
-        format: "parquet".into(),
-    },
-)]
-#[case::vortex_2_part(
-    "random-access/vortex-tokio-local-disk",
-    V3Bin::RandomAccess {
-        dataset: "taxi".into(),
-        format: "vortex-file-compressed".into(),
-    },
-)]
-#[case::lance_2_part(
-    "random-access/lance-tokio-local-disk",
-    V3Bin::RandomAccess {
-        dataset: "taxi".into(),
-        format: "lance".into(),
-    },
-)]
-fn random_access_2_part_legacy_recovered_as_taxi(#[case] name: &str, #[case] expected: V3Bin) {
-    // The 2-part shape `random-access/<format>-tokio-local-disk` is
-    // emitted by `random-access-bench`'s legacy taxi run (no
-    // `AccessPattern`, see `measurement_name` in
-    // `benchmarks/random-access-bench/src/main.rs`). The live v3
-    // emitter writes `dataset="taxi"` for those measurements, so the
-    // historical 2-part records on S3 must land in the same v3
-    // chart instead of being dropped as `UnsupportedShape`.
-    let r = record(name);
-    assert_eq!(
-        classify(&r),
-        Some(expected),
-        "2-part legacy random-access must recover as dataset=taxi"
-    );
-}
-
-#[rstest]
-#[case::parquet_footer("random-access/parquet-tokio-local-disk-footer")]
-#[case::vortex_footer("random-access/vortex-tokio-local-disk-footer")]
-#[case::lance_footer("random-access/lance-tokio-local-disk-footer")]
-fn random_access_2_part_footer_is_deprecated(#[case] name: &str) {
-    // The reopen-mode `-footer` variant is a different access pattern
-    // (file is reopened per take). The live v3 emitter passes the
-    // bare `format.name()` for both reopen and cached, so it can't
-    // distinguish them on the wire. Keep migration consistent with
-    // that by routing `-footer` 2-part records to Skip::Deprecated
-    // (they don't strip clean to a v3-allowlisted format).
-    let r = record(name);
-    assert!(
-        matches!(classify_outcome(&r), Outcome::Skip(Skip::Deprecated)),
-        "2-part `-footer` random-access must be Skip::Deprecated"
-    );
-}
-
-#[rstest]
-#[case::parquet_footer("random-access/taxi/correlated/parquet-tokio-local-disk-footer")]
-#[case::vortex_footer("random-access/feature-vectors/uniform/vortex-tokio-local-disk-footer")]
-#[case::lance_footer("random-access/nested-structs/correlated/lance-tokio-local-disk-footer")]
-fn random_access_4_part_footer_is_deprecated(#[case] name: &str) {
-    // Same reasoning as 2-part `-footer`: the format string ends in
-    // `-tokio-local-disk-footer`, the strip_suffix doesn't match, and
-    // the unstripped value fails the V3_FORMATS allowlist.
-    let r = record(name);
-    assert!(
-        matches!(classify_outcome(&r), Outcome::Skip(Skip::Deprecated)),
-        "4-part `-footer` random-access must be Skip::Deprecated"
-    );
-}
-
-#[test]
-fn parquet_zstd_size_is_deprecated() {
-    // `parquet-zstd` is not on the v3 emitter's format allowlist, so
-    // historical `parquet-zstd size/...` records bucket under
-    // Skip::Deprecated and don't render as orphan charts in v3.
-    let r = record("parquet-zstd size/clickbench");
-    assert!(matches!(
-        classify_outcome(&r),
-        Outcome::Skip(Skip::Deprecated)
-    ));
-}
-
-#[test]
-fn vortex_parquet_zstd_ratio_is_intentional_skip() {
-    let r = record("vortex:parquet-zstd ratio compress time/clickbench");
-    assert!(matches!(
-        classify_outcome(&r),
-        Outcome::Skip(Skip::DerivedRatio)
-    ));
-}
-
-#[test]
-fn vortex_parquet_zst_typo_ratio_is_intentional_skip() {
-    // `parquet-zst` (no trailing `d`) was emitted by some v2 runs.
-    // Both spellings should classify as derived ratios.
-    for name in [
-        "vortex:parquet-zst ratio compress time/clickbench",
-        "vortex:parquet-zst ratio decompress time/clickbench",
-    ] {
-        let r = record(name);
-        assert!(
-            matches!(classify_outcome(&r), Outcome::Skip(Skip::DerivedRatio)),
-            "{name:?} should be DerivedRatio",
-        );
-    }
-}
-
-#[test]
-fn throughput_is_intentional_skip() {
-    let r = record("compress throughput/clickbench");
-    assert!(matches!(
-        classify_outcome(&r),
-        Outcome::Skip(Skip::Throughput)
-    ));
-}
-
-#[test]
-fn unknown_prefix_is_unknown() {
-    let r = record("not-a-known-bench/series");
-    assert!(matches!(classify_outcome(&r), Outcome::Unknown));
-}
-
-#[test]
-fn gharchive_q00_is_deprecated() {
-    // gharchive isn't on the v3 query-suite allowlist, so historical
-    // gharchive query records bucket as Skip::Deprecated.
-    let r = record("gharchive_q00/datafusion:parquet");
-    assert!(matches!(
-        classify_outcome(&r),
-        Outcome::Skip(Skip::Deprecated)
-    ));
-}
-
-#[test]
-fn fineweb_q00_classifies() {
-    // fineweb is on V3_QUERY_SUITES (still emitted by v3 CI per
-    // .github/workflows/sql-benchmarks.yml's `fineweb` matrix entry),
-    // so historical fineweb records ingest like any other suite.
-    let r = record("fineweb_q00/datafusion:parquet");
-    assert!(matches!(
-        classify_outcome(&r),
-        Outcome::Bin(V3Bin::Query { .. })
-    ));
-}
-
-#[test]
-fn memory_record_is_historical_memory_skip() {
-    // v2 emitted `<suite>_q<NN>_memory/<engine>:<format>` records that
-    // carry top-level memory fields V2Record doesn't deserialize.
-    // Skip them with a known variant so they don't trip the 5% gate.
-    let r = record("clickbench_q07_memory/datafusion:parquet");
-    assert!(matches!(
-        classify_outcome(&r),
-        Outcome::Skip(Skip::HistoricalMemory)
-    ));
-}
-
-#[test]
-fn tpch_compression_size_carries_scale_factor() {
-    // The data.json.gz "vortex size/tpch" path needs to derive
-    // dataset_variant from the v2 record's `dataset` object, the same
-    // way the file-sizes path does. Otherwise SF=10 rows from the two
-    // sources never collide on `mid` and produce duplicate rows.
-    let mut r = record("vortex size/tpch");
-    r.dataset = Some(serde_json::json!({ "tpch": { "scale_factor": "10" } }));
-    let outcome = classify_outcome(&r);
-    let Outcome::Bin(V3Bin::CompressionSize {
-        dataset,
-        dataset_variant,
-        format,
-    }) = outcome
-    else {
-        panic!("expected Bin(CompressionSize), got {outcome:?}");
-    };
-    assert_eq!(dataset, "tpch");
-    assert_eq!(dataset_variant, Some("10".into()));
-    assert_eq!(format, "vortex-file-compressed");
-}
-
-#[test]
-fn tpch_compression_size_drops_default_scale_factor() {
-    // SF "1.0" matches the file-sizes path's filter and collapses to
-    // dataset_variant: None.
-    let mut r = record("vortex size/tpch");
-    r.dataset = Some(serde_json::json!({ "tpch": { "scale_factor": "1.0" } }));
-    let outcome = classify_outcome(&r);
-    let Outcome::Bin(V3Bin::CompressionSize {
-        dataset_variant, ..
-    }) = outcome
-    else {
-        panic!("expected Bin(CompressionSize), got {outcome:?}");
-    };
-    assert_eq!(dataset_variant, None);
-}
-
-#[rstest]
-// SF=1 is the implicit default; both spellings must drop to None so
-// `bin_compression_size` and `migrate_file_sizes` agree.
-#[case::int_one("1", None)]
-#[case::float_one("1.0", None)]
-// SF=10 must produce the same canonical string regardless of spelling.
-#[case::int_ten("10", Some("10".into()))]
-#[case::float_ten("10.0", Some("10".into()))]
-#[case::float_fractional("0.1", Some("0.1".into()))]
-#[case::whitespace("  10  ", Some("10".into()))]
-#[case::empty("", None)]
-fn compression_size_scale_factor_canonicalizes(
-    #[case] raw_sf: &str,
-    #[case] expected: Option<String>,
-) {
-    let mut r = record("vortex size/tpch");
-    r.dataset = Some(serde_json::json!({ "tpch": { "scale_factor": raw_sf } }));
-    let outcome = classify_outcome(&r);
-    let Outcome::Bin(V3Bin::CompressionSize {
-        dataset_variant, ..
-    }) = outcome
-    else {
-        panic!("expected Bin(CompressionSize) for sf={raw_sf:?}, got {outcome:?}");
-    };
-    assert_eq!(dataset_variant, expected, "sf={raw_sf:?}");
-}
-
-#[test]
-fn engine_casing_lowercased() {
-    // Older v2 records emitted display-case engines like `DataFusion`
-    // and `DuckDB`. The classifier lowercases at push time so dedup
-    // collapses display-case rows into the canonical lowercase ones.
-    let r = record("clickbench_q07/DataFusion:parquet");
-    let outcome = classify_outcome(&r);
-    let Outcome::Bin(V3Bin::Query { engine, format, .. }) = outcome else {
-        panic!("expected Bin(Query), got {outcome:?}");
-    };
-    assert_eq!(engine, "datafusion");
-    assert_eq!(format, "parquet");
-}
-
-#[test]
-fn rename_engine_pins_canonical_outputs() {
-    assert_eq!(rename_engine("vortex-tokio-local-disk"), "vortex-nvme");
-    assert_eq!(
-        rename_engine("datafusion:vortex-file-compressed"),
-        "datafusion:vortex"
-    );
-    assert_eq!(rename_engine("LANCE"), "lance");
-}
-
-#[test]
-fn format_query_pins_v2_display() {
-    assert_eq!(format_query("clickbench_q00"), "CLICKBENCH Q0");
-    assert_eq!(format_query("tpch_q22"), "TPC-H Q22");
-    assert_eq!(format_query("tpcds_q42"), "TPC-DS Q42");
-    assert_eq!(format_query("polarsignals_q1"), "POLARSIGNALS Q1");
-    // Names that don't match a suite fall back to upper + " " replace.
-    assert_eq!(
-        format_query("vortex-file-compressed size"),
-        "VORTEX FILE COMPRESSED SIZE"
-    );
-}
diff --git a/benchmarks-website/migrate/tests/end_to_end.rs b/benchmarks-website/migrate/tests/end_to_end.rs
deleted file mode 100644
index 83d71f5f156..00000000000
--- a/benchmarks-website/migrate/tests/end_to_end.rs
+++ /dev/null
@@ -1,452 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Inline JSONL fixtures driven through the full migration into a
-//! tempdir DuckDB. No live S3.
-
-use std::fs::File;
-use std::io::Write;
-use std::path::Path;
-
-use duckdb::Connection;
-use flate2::Compression;
-use flate2::write::GzEncoder;
-use tempfile::TempDir;
-use vortex_bench_migrate::migrate;
-use vortex_bench_migrate::source::Source;
-
-const COMMITS_JSONL: &str = r#"{"id":"deadbeef","timestamp":"2026-04-25T00:00:00Z","message":"fixture commit","author":{"name":"A","email":"a@example.com"},"committer":{"name":"C","email":"c@example.com"},"tree_id":"abcd0001","url":"https://example.com/commit/deadbeef"}
-"#;
-
-const DATA_JSONL: &str = r#"{"name":"clickbench_q07/datafusion:parquet","commit_id":"deadbeef","unit":"ns","value":42000,"all_runtimes":[41000,42000,43000]}
-{"name":"compress time/clickbench","commit_id":"deadbeef","unit":"ns","value":99}
-{"name":"vortex size/clickbench","commit_id":"deadbeef","unit":"bytes","value":1024}
-{"name":"random-access/taxi/take/parquet-tokio-local-disk","commit_id":"deadbeef","unit":"ns","value":777,"all_runtimes":[700,777,800]}
-"#;
-
-/// Build a local-source fixture directory. Caller supplies the contents
-/// of `commits.json`, `data.json.gz`, and any number of
-/// `file-sizes-*.json.gz` files (name → contents).
-fn build_fixture(commits: &str, data: &str, file_sizes: &[(&str, &str)]) -> TempDir {
-    let dir = TempDir::new().expect("tempdir");
-    write_text(&dir.path().join("commits.json"), commits);
-    write_gz(&dir.path().join("data.json.gz"), data);
-    for (name, body) in file_sizes {
-        write_gz(&dir.path().join(name), body);
-    }
-    dir
-}
-
-fn write_text(path: &Path, body: &str) {
-    let mut f = File::create(path).unwrap();
-    f.write_all(body.as_bytes()).unwrap();
-}
-
-fn write_gz(path: &Path, body: &str) {
-    let f = File::create(path).unwrap();
-    let mut gz = GzEncoder::new(f, Compression::default());
-    gz.write_all(body.as_bytes()).unwrap();
-    gz.finish().unwrap();
-}
-
-#[test]
-fn migrate_inline_fixture_populates_each_table() {
-    let src_dir = build_fixture(COMMITS_JSONL, DATA_JSONL, &[]);
-    let target_dir = TempDir::new().unwrap();
-    let target = target_dir.path().join("v3.duckdb");
-
-    let summary = migrate::run(&Source::Local(src_dir.path().into()), &target).unwrap();
-
-    assert_eq!(summary.records_read, 4, "summary={summary}");
-    assert_eq!(summary.uncategorized, 0, "summary={summary}");
-    assert_eq!(summary.commits_inserted, 1);
-    assert_eq!(summary.query_inserted, 1);
-    assert_eq!(summary.compression_time_inserted, 1);
-    assert_eq!(summary.compression_size_inserted, 1);
-    assert_eq!(summary.random_access_inserted, 1);
-
-    let conn = Connection::open(&target).unwrap();
-    let count = |table: &str| -> i64 {
-        conn.query_row(&format!("SELECT COUNT(*) FROM {table}"), [], |r| r.get(0))
-            .unwrap()
-    };
-    assert_eq!(count("commits"), 1);
-    assert_eq!(count("query_measurements"), 1);
-    assert_eq!(count("compression_times"), 1);
-    assert_eq!(count("compression_sizes"), 1);
-    assert_eq!(count("random_access_times"), 1);
-
-    // Spot-check the v3 column values for each kind.
-    let (engine, format, query_idx, value_ns): (String, String, i32, i64) = conn
-        .query_row(
-            "SELECT engine, format, query_idx, value_ns FROM query_measurements",
-            [],
-            |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?, r.get(3)?)),
-        )
-        .unwrap();
-    assert_eq!(engine, "datafusion");
-    assert_eq!(format, "parquet");
-    assert_eq!(query_idx, 7);
-    assert_eq!(value_ns, 42000);
-
-    let (dataset, format, op): (String, String, String) = conn
-        .query_row(
-            "SELECT dataset, format, op FROM compression_times",
-            [],
-            |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)),
-        )
-        .unwrap();
-    assert_eq!(dataset, "clickbench");
-    assert_eq!(format, "vortex-file-compressed");
-    assert_eq!(op, "encode");
-
-    let (dataset, format, value_bytes): (String, String, i64) = conn
-        .query_row(
-            "SELECT dataset, format, value_bytes FROM compression_sizes",
-            [],
-            |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)),
-        )
-        .unwrap();
-    assert_eq!(dataset, "clickbench");
-    assert_eq!(format, "vortex-file-compressed");
-    assert_eq!(value_bytes, 1024);
-
-    let (dataset, format): (String, String) = conn
-        .query_row("SELECT dataset, format FROM random_access_times", [], |r| {
-            Ok((r.get(0)?, r.get(1)?))
-        })
-        .unwrap();
-    assert_eq!(dataset, "taxi/take");
-    assert_eq!(format, "parquet");
-}
-
-#[test]
-fn dedup_collision_keeps_one_row() {
-    // Two data.json.gz lines whose query-measurement dim columns are
-    // identical (same commit / dataset / engine / format / query_idx,
-    // and `storage` collapses to "nvme" since `storage` is unset).
-    // Different `value`s. The accumulator's HashSet<measurement_id>
-    // should drop the second one and bump `summary.deduped`.
-    const DATA: &str = r#"{"name":"clickbench_q07/datafusion:parquet","commit_id":"deadbeef","unit":"ns","value":111}
-{"name":"clickbench_q07/datafusion:parquet","commit_id":"deadbeef","unit":"ns","value":222}
-"#;
-
-    let src_dir = build_fixture(COMMITS_JSONL, DATA, &[]);
-    let target_dir = TempDir::new().unwrap();
-    let target = target_dir.path().join("v3.duckdb");
-
-    let summary = migrate::run(&Source::Local(src_dir.path().into()), &target).unwrap();
-
-    assert_eq!(summary.records_read, 2, "summary={summary}");
-    assert_eq!(summary.query_inserted, 1, "summary={summary}");
-    assert_eq!(summary.deduped, 1, "summary={summary}");
-
-    let conn = Connection::open(&target).unwrap();
-    let n: i64 = conn
-        .query_row("SELECT COUNT(*) FROM query_measurements", [], |r| r.get(0))
-        .unwrap();
-    assert_eq!(n, 1);
-}
-
-#[test]
-fn dedup_with_conflicting_value_ns_is_counted() {
-    // Same dim columns, different `value`s. Dedup keeps the first
-    // and bumps `deduped_with_conflict` because the dropped row's
-    // value_ns differed from the kept row's. This is the signal we
-    // care about when watching for silent value-corruption across
-    // duplicated v2 emissions.
-    const DATA: &str = r#"{"name":"clickbench_q07/datafusion:parquet","commit_id":"deadbeef","unit":"ns","value":111}
-{"name":"clickbench_q07/datafusion:parquet","commit_id":"deadbeef","unit":"ns","value":222}
-"#;
-
-    let src_dir = build_fixture(COMMITS_JSONL, DATA, &[]);
-    let target_dir = TempDir::new().unwrap();
-    let target = target_dir.path().join("v3.duckdb");
-
-    let summary = migrate::run(&Source::Local(src_dir.path().into()), &target).unwrap();
-
-    assert_eq!(summary.deduped, 1, "summary={summary}");
-    assert_eq!(summary.deduped_with_conflict, 1, "summary={summary}");
-}
-
-#[test]
-fn dedup_with_matching_value_ns_does_not_count_conflict() {
-    // Same dim columns AND identical `value`s. Dedup still drops the
-    // duplicate, but `deduped_with_conflict` stays 0.
-    const DATA: &str = r#"{"name":"clickbench_q07/datafusion:parquet","commit_id":"deadbeef","unit":"ns","value":111}
-{"name":"clickbench_q07/datafusion:parquet","commit_id":"deadbeef","unit":"ns","value":111}
-"#;
-
-    let src_dir = build_fixture(COMMITS_JSONL, DATA, &[]);
-    let target_dir = TempDir::new().unwrap();
-    let target = target_dir.path().join("v3.duckdb");
-
-    let summary = migrate::run(&Source::Local(src_dir.path().into()), &target).unwrap();
-
-    assert_eq!(summary.deduped, 1, "summary={summary}");
-    assert_eq!(summary.deduped_with_conflict, 0, "summary={summary}");
-}
-
-#[test]
-fn compression_size_data_and_file_sizes_merge() {
-    // A `vortex size/tpch` record from data.json.gz and a
-    // file-sizes-tpch-nvme.json.gz row covering the same (commit,
-    // dataset, format, SF) tuple should produce the *same*
-    // measurement_id so the in-memory accumulator merges them into
-    // one row instead of two.
-    //
-    // Both sources use scale_factor "1.0", which both code paths
-    // filter out → dataset_variant: None on both sides → matching mid.
-    const DATA: &str = r#"{"name":"vortex size/tpch","commit_id":"deadbeef","unit":"bytes","value":200,"dataset":{"tpch":{"scale_factor":"1.0"}}}
-"#;
-    const FILE_SIZES: &str = r#"{"commit_id":"deadbeef","benchmark":"tpch","scale_factor":"1.0","format":"vortex-file-compressed","file":"part-0.vortex","size_bytes":100}
-"#;
-
-    let src_dir = build_fixture(
-        COMMITS_JSONL,
-        DATA,
-        &[("file-sizes-tpch-nvme.json.gz", FILE_SIZES)],
-    );
-    let target_dir = TempDir::new().unwrap();
-    let target = target_dir.path().join("v3.duckdb");
-
-    let summary = migrate::run(&Source::Local(src_dir.path().into()), &target).unwrap();
-
-    assert_eq!(summary.compression_size_inserted, 1, "summary={summary}");
-
-    let conn = Connection::open(&target).unwrap();
-    let (n, value_bytes): (i64, i64) = conn
-        .query_row(
-            "SELECT COUNT(*), SUM(value_bytes) FROM compression_sizes",
-            [],
-            |r| Ok((r.get(0)?, r.get(1)?)),
-        )
-        .unwrap();
-    assert_eq!(n, 1);
-    // data.json.gz seeds value_bytes=200, file-sizes adds 100.
-    assert_eq!(value_bytes, 300);
-}
-
-#[test]
-fn empty_author_email_stored_as_null() {
-    // v2 sometimes wrote `""` for blank author/email/message. The
-    // migrator normalizes those to None so DuckDB stores SQL NULL,
-    // letting the UI distinguish "missing metadata" from "empty
-    // string". Here author.email is "" — verify the column is NULL,
-    // not the empty string.
-    const COMMITS: &str = r#"{"id":"deadbeef","timestamp":"2026-04-25T00:00:00Z","message":"fixture","author":{"name":"A","email":""},"committer":{"name":"C","email":"c@example.com"},"tree_id":"abcd0001","url":"https://example.com/commit/deadbeef"}
-"#;
-
-    let src_dir = build_fixture(COMMITS, "", &[]);
-    let target_dir = TempDir::new().unwrap();
-    let target = target_dir.path().join("v3.duckdb");
-
-    migrate::run(&Source::Local(src_dir.path().into()), &target).unwrap();
-
-    let conn = Connection::open(&target).unwrap();
-    let is_null: bool = conn
-        .query_row(
-            "SELECT author_email IS NULL FROM commits WHERE commit_sha = 'deadbeef'",
-            [],
-            |r| r.get(0),
-        )
-        .unwrap();
-    assert!(is_null, "empty author.email must store as SQL NULL");
-
-    // Non-empty fields still round-trip as strings.
-    let committer_email: String = conn
-        .query_row(
-            "SELECT committer_email FROM commits WHERE commit_sha = 'deadbeef'",
-            [],
-            |r| r.get(0),
-        )
-        .unwrap();
-    assert_eq!(committer_email, "c@example.com");
-}
-
-#[test]
-fn open_target_db_removes_orphan_wal() {
-    // A `.wal` left from a previous crash with no main file present
-    // must still be removed so the next run starts from a known-empty
-    // state. Otherwise DuckDB can replay stale WAL into the fresh DB
-    // and corrupt subsequent inserts.
-    let target_dir = TempDir::new().unwrap();
-    let target = target_dir.path().join("v3.duckdb");
-    let wal = target_dir.path().join("v3.duckdb.wal");
-    std::fs::write(&wal, b"orphan-wal-bytes").unwrap();
-    assert!(wal.exists(), "precondition: orphan wal staged");
-    assert!(!target.exists(), "precondition: no main db file");
-
-    {
-        let _conn = migrate::open_target_db(&target).unwrap();
-    }
-
-    // The migrator opens the DB after sweeping the WAL; DuckDB may
-    // recreate its own wal under load, but our pre-existing orphan
-    // bytes must not survive the sweep. We assert by content: either
-    // the path is missing, or its contents differ from the orphan we
-    // staged.
-    if wal.exists() {
-        let now = std::fs::read(&wal).unwrap();
-        assert_ne!(
-            now, b"orphan-wal-bytes",
-            "orphan wal bytes must not survive open_target_db"
-        );
-    }
-}
-
-#[test]
-fn file_sizes_unknown_id_falls_back_to_unknown_prefix() {
-    // A file-sizes-*.json.gz whose id isn't in
-    // `KNOWN_FILE_SIZES_SUITES`, with an empty `benchmark` field, used
-    // to surface as a bare id like `mystery-suite` and render as a
-    // dataset name. The migrator now prefixes those with `unknown:`
-    // so the UI can flag them.
-    const FILE_SIZES: &str = r#"{"commit_id":"deadbeef","benchmark":"","scale_factor":"","format":"vortex-file-compressed","file":"part-0.vortex","size_bytes":1000}
-"#;
-
-    let src_dir = build_fixture(
-        COMMITS_JSONL,
-        "",
-        &[("file-sizes-mystery-suite.json.gz", FILE_SIZES)],
-    );
-    let target_dir = TempDir::new().unwrap();
-    let target = target_dir.path().join("v3.duckdb");
-
-    migrate::run(&Source::Local(src_dir.path().into()), &target).unwrap();
-
-    let conn = Connection::open(&target).unwrap();
-    let dataset: String = conn
-        .query_row("SELECT dataset FROM compression_sizes", [], |r| r.get(0))
-        .unwrap();
-    assert_eq!(dataset, "unknown:mystery-suite");
-}
-
-#[test]
-fn file_sizes_known_id_uses_id_directly() {
-    // For a KNOWN_FILE_SIZES_SUITES id, the fallback path keeps the
-    // raw id (no `unknown:` prefix). `clickbench-nvme` is on the list.
-    const FILE_SIZES: &str = r#"{"commit_id":"deadbeef","benchmark":"","scale_factor":"","format":"vortex-file-compressed","file":"part-0.vortex","size_bytes":1000}
-"#;
-
-    let src_dir = build_fixture(
-        COMMITS_JSONL,
-        "",
-        &[("file-sizes-clickbench-nvme.json.gz", FILE_SIZES)],
-    );
-    let target_dir = TempDir::new().unwrap();
-    let target = target_dir.path().join("v3.duckdb");
-
-    migrate::run(&Source::Local(src_dir.path().into()), &target).unwrap();
-
-    let conn = Connection::open(&target).unwrap();
-    let dataset: String = conn
-        .query_row("SELECT dataset FROM compression_sizes", [], |r| r.get(0))
-        .unwrap();
-    assert_eq!(dataset, "clickbench-nvme");
-}
-
-#[test]
-fn compression_size_data_and_file_sizes_merge_with_canonical_sf() {
-    // Same logical SF written as `"10"` on the data.json.gz side and
-    // `"10.0"` on the file-sizes side. Both paths must canonicalize
-    // to `"10"` so the rows share a `measurement_id` and merge into
-    // one compression_sizes row.
-    const DATA: &str = r#"{"name":"vortex size/tpch","commit_id":"deadbeef","unit":"bytes","value":200,"dataset":{"tpch":{"scale_factor":"10"}}}
-"#;
-    const FILE_SIZES: &str = r#"{"commit_id":"deadbeef","benchmark":"tpch","scale_factor":"10.0","format":"vortex-file-compressed","file":"part-0.vortex","size_bytes":100}
-"#;
-
-    let src_dir = build_fixture(
-        COMMITS_JSONL,
-        DATA,
-        &[("file-sizes-tpch-nvme-10.json.gz", FILE_SIZES)],
-    );
-    let target_dir = TempDir::new().unwrap();
-    let target = target_dir.path().join("v3.duckdb");
-
-    let summary = migrate::run(&Source::Local(src_dir.path().into()), &target).unwrap();
-
-    assert_eq!(summary.compression_size_inserted, 1, "summary={summary}");
-    let conn = Connection::open(&target).unwrap();
-    let (n, value_bytes, dataset_variant): (i64, i64, String) = conn
-        .query_row(
-            "SELECT COUNT(*), SUM(value_bytes), MAX(dataset_variant) FROM compression_sizes",
-            [],
-            |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)),
-        )
-        .unwrap();
-    assert_eq!(n, 1);
-    // data.json.gz seeds 200, file-sizes adds 100.
-    assert_eq!(value_bytes, 300);
-    assert_eq!(dataset_variant, "10");
-}
-
-#[test]
-fn summary_counts_match_actual_rows_on_success() {
-    // Sister test to migrate::tests::flush_all_does_not_overcount_on_failure.
-    // On a fully successful run, the post-flush summary counters must
-    // equal `SELECT COUNT(*)` from each fact table. This is the
-    // invariant the flush-after-count refactor preserves.
-    let src_dir = build_fixture(COMMITS_JSONL, DATA_JSONL, &[]);
-    let target_dir = TempDir::new().unwrap();
-    let target = target_dir.path().join("v3.duckdb");
-
-    let summary = migrate::run(&Source::Local(src_dir.path().into()), &target).unwrap();
-
-    let conn = Connection::open(&target).unwrap();
-    let actual = |table: &str| -> u64 {
-        let n: i64 = conn
-            .query_row(&format!("SELECT COUNT(*) FROM {table}"), [], |r| r.get(0))
-            .unwrap();
-        n as u64
-    };
-    assert_eq!(summary.query_inserted, actual("query_measurements"));
-    assert_eq!(
-        summary.compression_time_inserted,
-        actual("compression_times")
-    );
-    assert_eq!(
-        summary.compression_size_inserted,
-        actual("compression_sizes")
-    );
-    assert_eq!(
-        summary.random_access_inserted,
-        actual("random_access_times")
-    );
-}
-
-#[test]
-fn file_sizes_sum_into_one_row() {
-    // Two file-sizes rows sharing (commit, benchmark, format,
-    // scale_factor) and value_bytes 100 + 200 must collapse to a
-    // single compression_sizes row with 300.
-    const FILE_SIZES: &str = r#"{"commit_id":"deadbeef","benchmark":"clickbench","scale_factor":"1.0","format":"vortex-file-compressed","file":"part-0.vortex","size_bytes":100}
-{"commit_id":"deadbeef","benchmark":"clickbench","scale_factor":"1.0","format":"vortex-file-compressed","file":"part-1.vortex","size_bytes":200}
-"#;
-
-    let src_dir = build_fixture(
-        COMMITS_JSONL,
-        "",
-        &[("file-sizes-clickbench.json.gz", FILE_SIZES)],
-    );
-    let target_dir = TempDir::new().unwrap();
-    let target = target_dir.path().join("v3.duckdb");
-
-    let summary = migrate::run(&Source::Local(src_dir.path().into()), &target).unwrap();
-
-    assert_eq!(summary.file_size_inserted, 2, "summary={summary}");
-    assert_eq!(summary.compression_size_inserted, 1, "summary={summary}");
-
-    let conn = Connection::open(&target).unwrap();
-    let n: i64 = conn
-        .query_row("SELECT COUNT(*) FROM compression_sizes", [], |r| r.get(0))
-        .unwrap();
-    assert_eq!(n, 1);
-    let value_bytes: i64 = conn
-        .query_row("SELECT value_bytes FROM compression_sizes", [], |r| {
-            r.get(0)
-        })
-        .unwrap();
-    assert_eq!(value_bytes, 300);
-}
diff --git a/benchmarks-website/ops/BOOTSTRAP.md b/benchmarks-website/ops/BOOTSTRAP.md
deleted file mode 100644
index 391f8717980..00000000000
--- a/benchmarks-website/ops/BOOTSTRAP.md
+++ /dev/null
@@ -1,741 +0,0 @@
-<!--
-SPDX-License-Identifier: Apache-2.0
-SPDX-FileCopyrightText: Copyright the Vortex contributors
--->
-
-# vortex-bench-server bootstrap and recovery walkthrough
-
-A linear, copy-paste runbook for two scenarios:
-
-1. **Fresh install**: empty EC2 host, no DB, no S3 backups yet. Phases 1 through 7.
-2. **Disaster recovery**: rebuild the site from S3 backups onto a new host (the old host is gone or
-   its DB is unrecoverable). Phases 1 through 6, then phase 8.
-
-[`README.md`](README.md) is the topic-organized reference manual; this file is the recipe you follow
-top-to-bottom. Every step has a verification command so you can confirm it landed before moving on.
-If a verification fails, the troubleshooting note below it points at the most likely cause.
-
-## Conventions
-
-- `$` lines are shell commands. Lines without `$` are example output.
-- Run everything as `ec2-user` on the EC2 host unless a step says otherwise. `sudo` is called
-  explicitly where needed.
-- The deploy timer cannot fetch over SSH. The repo's `origin` remote MUST be the HTTPS URL
-  `https://github.com/vortex-data/vortex.git`. If you already cloned over SSH, fix it in place:
-  `git -C ~/vortex remote set-url origin https://github.com/vortex-data/vortex.git`.
-- `/var/lib/vortex-bench/ops/` is a directory symlink that `install.sh` creates pointing at
-  `<repo>/benchmarks-website/ops/`. Every script under it lives in the repo; the symlink is the
-  source-of-truth pointer. Deleting `~/vortex` breaks all five systemd units atomically.
-
-## Phase 1: AWS prerequisites (one-time, from the AWS console)
-
-Skip this entire phase if you are rebuilding into an EC2 instance that already has the
-`VortexBenchServerRole` IAM role attached and the bucket lifecycle rule in place. Both survive
-instance termination.
-
-### 1.1 Create the IAM policy
-
-In **IAM → Policies → Create policy**, paste:
-
-```json
-{
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Sid": "ListBucket",
-      "Effect": "Allow",
-      "Action": "s3:ListBucket",
-      "Resource": "arn:aws:s3:::vortex-benchmark-results-database"
-    },
-    {
-      "Sid": "ReadWriteV3Backups",
-      "Effect": "Allow",
-      "Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"],
-      "Resource": "arn:aws:s3:::vortex-benchmark-results-database/v3-backups/*"
-    }
-  ]
-}
-```
-
-Name it `VortexBenchV3Backups`.
-
-### 1.2 Create the role and attach it
-
-1. **IAM → Roles → Create role → AWS service → EC2**, attach `VortexBenchV3Backups`, name it
-   `VortexBenchServerRole`.
-2. **EC2 → Instances → bench instance → Actions → Security → Modify IAM role**, pick
-   `VortexBenchServerRole`, click Update.
-3. Wait about 15 seconds for the instance metadata service to refresh.
-
-### 1.3 Create the S3 lifecycle rule
-
-**S3 → Buckets → vortex-benchmark-results-database → Management → Lifecycle rules → Create lifecycle
-rule**:
-
-| Field        | Value                                          |
-| ------------ | ---------------------------------------------- |
-| Name         | `v3-backups-7d`                                |
-| Status       | Enabled                                        |
-| Filter scope | Prefix `v3-backups/`                           |
-| Action       | Expire current versions, 7 days after creation |
-
-7 days at one snapshot per hour is 168 tarballs. Tune up or down to taste.
-
-### 1.4 Verify
-
-```bash
-$ aws sts get-caller-identity
-# Arn should end in /VortexBenchServerRole/<instance-id>
-
-$ echo probe > /tmp/probe.txt
-$ aws s3 cp /tmp/probe.txt s3://vortex-benchmark-results-database/v3-backups/_probe.txt
-$ aws s3 ls s3://vortex-benchmark-results-database/v3-backups/ | grep probe
-$ aws s3 rm s3://vortex-benchmark-results-database/v3-backups/_probe.txt
-$ rm /tmp/probe.txt
-```
-
-All four operations must succeed. If any fails with `AccessDenied`, check (1) the policy is actually
-attached to `VortexBenchServerRole`, (2) the instance is using that role per
-`aws sts get-caller-identity`, (3) there is no bucket policy denying access.
-
-## Phase 2: Host packages (Amazon Linux 2023)
-
-```bash
-$ sudo dnf install -y \
-    git curl jq \
-    gcc gcc-c++ make cmake pkgconfig \
-    util-linux openssl tar gzip
-```
-
-`util-linux` provides `flock`, which `deploy.sh` uses as a serialization guard. `gcc`, `gcc-c++`,
-`cmake`, and `pkgconfig` are required by the `duckdb-sys` build.
-
-### 2.1 Install the Rust toolchain for `ec2-user`
-
-```bash
-$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
-$ source $HOME/.cargo/env
-$ rustc --version
-```
-
-`rustc --version` must succeed. The deploy timer runs `cargo build --release`, which needs this
-exact toolchain installed for the user systemd runs the service as (`ec2-user`).
-
-## Phase 3: Clone the repo
-
-```bash
-$ cd ~ && git clone https://github.com/vortex-data/vortex.git
-$ cd vortex
-$ git remote -v
-origin  https://github.com/vortex-data/vortex.git (fetch)
-origin  https://github.com/vortex-data/vortex.git (push)
-```
-
-The HTTPS URL is mandatory. If your `git config` defaults rewrite to SSH, undo that for this
-checkout:
-
-```bash
-$ git -C ~/vortex remote set-url origin https://github.com/vortex-data/vortex.git
-```
-
-## Phase 4: Run the installer
-
-```bash
-$ ./benchmarks-website/ops/install.sh
-```
-
-This is idempotent. It creates `/var/lib/vortex-bench/` owned by `ec2-user` (logs go to
-journalctl, not to a file), drops a sudoers fragment at `/etc/sudoers.d/vortex-bench`, copies
-`/etc/vortex-bench.env` from the template (mode 0600), symlinks `/var/lib/vortex-bench/ops` to the
-repo's `ops/`, and installs the systemd units.
-
-Expected tail of output:
-
-```
-[install] install complete. Next steps:
-[install]   1. Edit /etc/vortex-bench.env (chmod 0600, owned by ec2-user)
-[install]      - INGEST_BEARER_TOKEN=...
-[install]      - ADMIN_BEARER_TOKEN=...
-```
-
-If the installer warns about an SSH `origin` remote, fix it now (see Phase 3) before starting the
-timers. The deploy timer will silently fail every minute otherwise.
-
-### 4.1 Verify
-
-```bash
-$ ls -ld /var/lib/vortex-bench
-drwxr-xr-x. 7 ec2-user ec2-user 4096 ... /var/lib/vortex-bench
-
-$ sudo ls -l /etc/vortex-bench.env
--rw-------. 1 ec2-user ec2-user ... /etc/vortex-bench.env
-
-$ systemctl list-unit-files 'vortex-bench-*' --no-pager
-vortex-bench-backup.service        static
-vortex-bench-backup.timer          enabled
-vortex-bench-deploy.service        static
-vortex-bench-deploy.timer          enabled
-vortex-bench-server.service        enabled
-```
-
-`enabled` for the two timers and the server unit is the expected state. The deploy and backup
-service units are `static` because they have no `[Install]` section and are fired by their
-respective timers, not enabled directly.
-
-## Phase 5: Fill in the env file and start the timers
-
-### 5.1 Generate the two bearer tokens
-
-```bash
-$ openssl rand -hex 32    # this becomes INGEST_BEARER_TOKEN
-$ openssl rand -hex 32    # this becomes ADMIN_BEARER_TOKEN
-```
-
-Save the `INGEST_BEARER_TOKEN` to the GitHub Actions Environment that the bench CI workflow reads.
-The `ADMIN_BEARER_TOKEN` never leaves the box.
-
-### 5.2 Edit `/etc/vortex-bench.env`
-
-```bash
-$ sudo $EDITOR /etc/vortex-bench.env
-```
-
-Required fields (defaults are correct for the canonical layout):
-
-```
-INGEST_BEARER_TOKEN=<the first token from above>
-ADMIN_BEARER_TOKEN=<the second token from above>
-REPO_DIR=/home/ec2-user/vortex
-DEPLOY_BRANCH=develop
-S3_BACKUP_PREFIX=s3://vortex-benchmark-results-database/v3-backups
-```
-
-The remaining keys (`VORTEX_BENCH_DB`, `VORTEX_BENCH_BIND`, `VORTEX_BENCH_ADMIN_BIND`, `SERVER_URL`,
-`ADMIN_URL`, `VORTEX_BENCH_SNAPSHOT_DIR`) already point at the canonical paths.
-
-### 5.3 Start the timers
-
-```bash
-$ sudo systemctl start vortex-bench-deploy.timer
-$ sudo systemctl start vortex-bench-backup.timer
-```
-
-The server unit starts itself once the deploy timer's first fire produces a binary. Do not
-`start vortex-bench-server` directly yet, there is nothing for it to exec.
-
-### 5.4 Watch the first deploy build the binary
-
-```bash
-$ journalctl -fu vortex-bench-deploy.service
-```
-
-The first fire takes about 60 to 90 seconds for a cold `cargo build --release`. Every log line is
-prefixed with `[deploy <UTC-ts>]`. Look for these milestones (paraphrased; the literal substrings
-to grep are bolded):
-
-- **`building <7-char-sha> (was <prev>)`** -- cargo build starts.
-- **`swapped symlink →`** -- atomic binary swap landed; the next /health probe is imminent.
-  (The arrow is the literal Unicode `→` deploy.sh emits, not ASCII `->`.)
-- **`deploy ok: <7-char-sha> → live (binary <ts>)`** -- /health passed and the deploy committed
-  the stamp. This is the success line.
-
-`Ctrl-C` out of `journalctl` once the `deploy ok:` line appears. If a deploy fails it will exit
-with one of the exit codes documented at the head of [`deploy.sh`](deploy.sh): 1 lock contention,
-2 config error, 3 git fetch or checkout, 4 cargo build, 5 systemctl restart (with rollback
-re-probed), 6 /health failed but rolled back OK, 7 /health failed AND rollback also broken --
-server is down. The four exit codes a bootstrap operator typically hits (4 through 7) have rows
-in [the symptom table](#what-to-do-if-a-step-fails) below; exit codes 1-3 are self-explanatory
-in the journal output.
-
-## Phase 6: Verify the server is up
-
-### 6.1 Public listener
-
-```bash
-$ curl -fsS http://127.0.0.1:3000/health | jq
-{
-  "status": "ok",
-  "build_sha": "abc123...",
-  "schema_version": "...",
-  "db_path": "/var/lib/vortex-bench/bench.duckdb",
-  "row_counts": {
-    "commits": 0,
-    "query_measurements": 0,
-    ...
-  }
-}
-```
-
-Empty row counts are expected. The DB is created with an empty schema on first server boot.
-
-### 6.2 Admin listener
-
-```bash
-$ /var/lib/vortex-bench/ops/inspect.sh "SELECT COUNT(*) FROM commits;"
-```
-
-A `0` is correct (DB is empty). A connection refused means `ADMIN_BEARER_TOKEN` was empty when the
-server started: re-check `/etc/vortex-bench.env` and restart the server with
-`/var/lib/vortex-bench/ops/restart.sh`.
-
-### 6.3 Build SHA
-
-```bash
-$ readlink /var/lib/vortex-bench/bin/vortex-bench-server
-/var/lib/vortex-bench/bin/vortex-bench-server.<UTC-ts>.<pid>
-
-$ cat /var/lib/vortex-bench/last-deployed-sha
-abc123...
-```
-
-The SHA in `last-deployed-sha` must match the `build_sha` in the `/health` JSON.
-
-## Phase 7: Populate the database (fresh install only)
-
-Pick **one** of 7.A or 7.B. Skip this entire phase if you are rebuilding from a backup (Phase 8
-supplies the data).
-
-### 7.A Run the v2 to v3 migration
-
-This is the canonical path for a brand-new install. The migrator reads the v2 source (the public
-S3 bucket of v2 result JSONs) and writes into the v3 DuckDB file.
-
-```bash
-$ source /etc/vortex-bench.env
-# Check the migrator's own CLI for the up-to-date flag set. The wrapper passes args verbatim to
-# `cargo run -p vortex-bench-migrate -- "$@"`, so the v2 source flag lives in that crate:
-$ /var/lib/vortex-bench/ops/migrate.sh run --help
-# Typical invocation (substitute the v2 source flag the --help output names):
-$ /var/lib/vortex-bench/ops/migrate.sh run --output "$VORTEX_BENCH_DB"
-```
-
-`migrate.sh` stops the server, snapshots the current DB to `bench.prev-<ts>.duckdb` for rollback,
-runs the migrator, and starts the server back up. The deploy and backup timers are paused for the
-duration; they restart automatically on success.
-
-If the migrator fails, the script leaves the server stopped and the timers paused, and prints the
-exact rollback command. Follow it. Do not retry the migration without rolling back first or you will
-pile new state on top of partially-migrated state.
-
-### 7.B Promote an existing DuckDB file
-
-If you already have a `bench.duckdb` from a previous host or a manual export:
-
-```bash
-$ sudo systemctl stop vortex-bench-server
-$ cp /path/to/your/bench.duckdb /var/lib/vortex-bench/bench.duckdb
-$ sudo systemctl start vortex-bench-server
-$ curl -fsS http://127.0.0.1:3000/health | jq '.row_counts'
-```
-
-Row counts in `/health` should match the source DB.
-
-### 7.C Verify the data landed
-
-```bash
-$ /var/lib/vortex-bench/ops/inspect.sh "
-    SELECT 'commits' AS table_name, COUNT(*) AS n FROM commits
-    UNION ALL SELECT 'query_measurements', COUNT(*) FROM query_measurements
-    UNION ALL SELECT 'compression_times', COUNT(*) FROM compression_times
-    UNION ALL SELECT 'compression_sizes', COUNT(*) FROM compression_sizes
-    UNION ALL SELECT 'random_access_times', COUNT(*) FROM random_access_times
-    UNION ALL SELECT 'vector_search_runs', COUNT(*) FROM vector_search_runs;
-"
-```
-
-All six tables should have non-zero row counts that match what you expect from the source.
-
-### 7.D Verify the backup loop end-to-end
-
-Fire one snapshot by hand to prove the IAM role, the admin token, and the tarball pipeline all work:
-
-```bash
-$ sudo systemctl start vortex-bench-backup.service
-$ journalctl -u vortex-bench-backup.service --since '2 min ago' --no-pager
-[backup ...] triggering /api/admin/snapshot?ts=20260520T...
-[backup ...] compressing /var/lib/vortex-bench/snapshots/... → ....tar.gz
-[backup ...] compressed N → M bytes (Kx)
-[backup ...] uploading ....tar.gz → s3://vortex-benchmark-results-database/v3-backups/....tar.gz
-[backup ...] deleting local copies ...
-[backup ...] snapshot 20260520T... ok → ...
-
-$ aws s3 ls s3://vortex-benchmark-results-database/v3-backups/ | tail -3
-```
-
-The tarball must appear in the listing. If `aws s3 cp` fails with `AccessDenied`, redo Phase 1.4 to
-debug the IAM role.
-
-**At this point the system is fully self-driving.** Deploys land within 60 seconds of a develop
-merge, snapshots upload every hour, the lifecycle rule expires old ones. You do not need to SSH back
-in for routine operations.
-
-## Phase 8: Disaster recovery: restore the DB from an S3 backup
-
-Use this phase to rebuild onto a fresh host when the old host or DB is unrecoverable. **Do not run
-it on a healthy host with a populated DB**, it overwrites the live `bench.duckdb`.
-
-You must have completed Phases 1 through 6 first (the server runs against an empty schema). Skip
-Phase 7.
-
-### 8.1 Pick the snapshot you want to restore
-
-```bash
-$ aws s3 ls s3://vortex-benchmark-results-database/v3-backups/ | tail -20
-2026-05-20 01:00:14   12345678 20260520T010000Z.tar.gz
-2026-05-20 02:00:11   12345678 20260520T020000Z.tar.gz
-...
-```
-
-The lifecycle rule keeps about 168 hourly snapshots (7 days). Pick the most recent known-good one,
-or `tail -1` to grab the latest.
-
-### 8.2 Download and extract
-
-```bash
-$ ts=20260520T020000Z   # replace with the timestamp from 8.1
-$ cd /tmp
-$ aws s3 cp "s3://vortex-benchmark-results-database/v3-backups/${ts}.tar.gz" .
-$ tar xzf "${ts}.tar.gz"
-$ ls /tmp/${ts}/
-schema.sql
-commits.vortex
-query_measurements.vortex
-compression_times.vortex
-compression_sizes.vortex
-random_access_times.vortex
-vector_search_runs.vortex
-```
-
-Six `.vortex` files plus `schema.sql`. If any file is missing, the snapshot is incomplete, pick an
-earlier one.
-
-### 8.3 Stop the server and clear the empty DB
-
-```bash
-$ sudo systemctl stop vortex-bench-server
-$ rm -f \
-    /var/lib/vortex-bench/bench.duckdb \
-    /var/lib/vortex-bench/bench.duckdb.wal
-```
-
-(`bench.duckdb` is owned by `ec2-user` per the install layout; deleting it does not need sudo.)
-
-### 8.4 Install the duckdb CLI matching the bundled engine
-
-```bash
-$ duckdb --version
-v1.5.x ...
-```
-
-The CLI version must be at least as new as the engine the server bundles (currently `1.5.x`). If
-`duckdb` is missing or older:
-
-```bash
-$ curl -L https://github.com/duckdb/duckdb/releases/latest/download/duckdb_cli-linux-amd64.zip -o /tmp/duckdb.zip
-$ unzip -j /tmp/duckdb.zip duckdb -d ~/bin
-$ export PATH="$HOME/bin:$PATH"
-$ duckdb --version
-```
-
-### 8.5 Rehydrate the DB from the snapshot
-
-The block below uses `${ts}` from Phase 8.2; the guard re-derives it from `/tmp/` if a fresh shell
-lost the variable, so this step is safe to copy-paste into a new terminal.
-
-```bash
-$ : "${ts:?ts is not set; \`ts=<the-timestamp>\` or re-source /etc/vortex-bench.env}"
-$ [ -d "/tmp/${ts}" ] || { echo "missing /tmp/${ts}; redo 8.2" >&2; exit 1; }
-$ duckdb /var/lib/vortex-bench/bench.duckdb <<EOF
-INSTALL vortex;
-LOAD vortex;
-.read /tmp/${ts}/schema.sql
-INSERT INTO commits             SELECT * FROM read_vortex('/tmp/${ts}/commits.vortex');
-INSERT INTO query_measurements  SELECT * FROM read_vortex('/tmp/${ts}/query_measurements.vortex');
-INSERT INTO compression_times   SELECT * FROM read_vortex('/tmp/${ts}/compression_times.vortex');
-INSERT INTO compression_sizes   SELECT * FROM read_vortex('/tmp/${ts}/compression_sizes.vortex');
-INSERT INTO random_access_times SELECT * FROM read_vortex('/tmp/${ts}/random_access_times.vortex');
-INSERT INTO vector_search_runs  SELECT * FROM read_vortex('/tmp/${ts}/vector_search_runs.vortex');
-EOF
-```
-
-The server's startup applies `CREATE TABLE IF NOT EXISTS` idempotently against this populated DB,
-so 8.6 will not error on already-present tables.
-
-If `INSTALL vortex` fails with `extension not found` and `8.4` does not fix it, the upstream
-DuckDB community/core extension index is currently the only restore vector for v3 snapshots.
-File an issue: a cargo-driven restore fallback (`vortex-bench-migrate restore --input ...`) is
-worth building before the next disaster recovery if the extension goes intermittently missing.
-
-If `INSTALL vortex` fails with `extension not found`, the CLI is older than the release that
-publishes the vortex core extension. Upgrade per 8.4.
-
-### 8.6 Fix ownership and start the server
-
-```bash
-$ sudo chown ec2-user:ec2-user /var/lib/vortex-bench/bench.duckdb
-$ sudo systemctl start vortex-bench-server
-$ curl -fsS http://127.0.0.1:3000/health | jq '.row_counts'
-```
-
-Row counts should match the source. If `/health` reports zeros, the `INSERT INTO` statements
-silently no-op'd. The most common cause is `schema.sql` having already been read but the `INSERT`
-step erroring, check the CLI output above.
-
-### 8.7 Clean up
-
-```bash
-$ rm -rf /tmp/${ts} /tmp/${ts}.tar.gz
-```
-
-The hourly backup timer will resume on its own schedule. Watch one fire to confirm the recovered
-host is fully online:
-
-```bash
-$ sudo systemctl start vortex-bench-backup.service
-$ journalctl -u vortex-bench-backup.service --since '2 min ago' --no-pager
-```
-
-## Phase 9: Rollback a bad migration (alternative recovery path)
-
-If you ran `migrate.sh` and the result is wrong but the host is otherwise healthy, you do not need
-S3, the prev DB is on local disk.
-
-```bash
-$ ls -t /var/lib/vortex-bench/bench.prev-*.duckdb | head -3
-/var/lib/vortex-bench/bench.prev-20260520T123000Z.duckdb
-/var/lib/vortex-bench/bench.prev-20260518T040000Z.duckdb
-```
-
-Pick the most recent prev DB (just before the failed migrate ran):
-
-```bash
-$ prev=/var/lib/vortex-bench/bench.prev-20260520T123000Z.duckdb
-$ sudo systemctl stop vortex-bench-server
-$ mv "$prev" /var/lib/vortex-bench/bench.duckdb
-$ [ -f "${prev}.wal" ] && mv "${prev}.wal" /var/lib/vortex-bench/bench.duckdb.wal
-$ sudo systemctl start vortex-bench-server
-$ sudo systemctl start vortex-bench-deploy.timer
-$ sudo systemctl start vortex-bench-backup.timer
-$ curl -fsS http://127.0.0.1:3000/health | jq '.row_counts'
-```
-
-The autopilot timers may have been stopped by the failed `migrate.sh`. Starting them here is
-idempotent.
-
-## Steady-state operations
-
-These are the commands you actually use day-to-day. None of them require having read this file from
-the top, and none of them touch the data path.
-
-### Inspect
-
-```bash
-# Is the site up?
-$ curl -fsS http://127.0.0.1:3000/health | jq
-
-# Which build is actually running (three identifiers; all three should agree).
-$ cat /var/lib/vortex-bench/last-deployed-sha       # what the deploy timer last rolled out
-$ readlink /var/lib/vortex-bench/bin/vortex-bench-server   # what the symlink points at
-$ curl -fsS http://127.0.0.1:3000/health | jq '.build_sha' # what the live process baked in
-
-# Tail the next deploy live.
-$ journalctl -fu vortex-bench-deploy.service
-
-# Recent deploy attempts (success or failure).
-$ journalctl -u vortex-bench-deploy.service --since '15 min ago' --no-pager
-
-# Backup timer status (when did it last fire? when will it fire next?).
-$ systemctl list-timers vortex-bench-backup.timer
-$ journalctl -u vortex-bench-backup.service --since '4 hours ago' --no-pager
-
-# Disk usage by component (when /var/lib/vortex-bench is filling up).
-$ du -sh /var/lib/vortex-bench/* | sort -h
-```
-
-### Read the DB (no server stop)
-
-```bash
-# Ad-hoc read-only SQL. SELECT/WITH/PRAGMA/SHOW/DESCRIBE/EXPLAIN only.
-$ /var/lib/vortex-bench/ops/inspect.sh "SELECT COUNT(*) FROM commits;"
-
-# JSON output (handier in pipelines).
-$ /var/lib/vortex-bench/ops/inspect.sh -j "SELECT * FROM commits LIMIT 1" | jq
-
-# Row counts across all six tables.
-$ /var/lib/vortex-bench/ops/inspect.sh "
-    SELECT 'commits' AS t, COUNT(*) AS n FROM commits
-    UNION ALL SELECT 'query_measurements', COUNT(*) FROM query_measurements
-    UNION ALL SELECT 'compression_times',   COUNT(*) FROM compression_times
-    UNION ALL SELECT 'compression_sizes',   COUNT(*) FROM compression_sizes
-    UNION ALL SELECT 'random_access_times', COUNT(*) FROM random_access_times
-    UNION ALL SELECT 'vector_search_runs',  COUNT(*) FROM vector_search_runs;
-"
-```
-
-### Restart / redeploy
-
-Three knobs, in increasing order of work done:
-
-```bash
-# (a) Restart the binary in place. No rebuild. Use this after editing
-#     /etc/vortex-bench.env or recovering from a stuck connection.
-#     Prints before/after pid + binary path + /health JSON (which carries
-#     build_sha) so you can confirm the swap.
-$ /var/lib/vortex-bench/ops/restart.sh
-
-# (b) Run a deploy now if origin has moved (otherwise a no-op).
-$ sudo systemctl start vortex-bench-deploy.service
-$ journalctl -fu vortex-bench-deploy.service
-
-# (c) Force-rebuild whatever is on $DEPLOY_BRANCH even when origin
-#     has not moved (ignores the stamp file and the path filter).
-$ /var/lib/vortex-bench/ops/force-rebuild.sh
-$ journalctl -fu vortex-bench-deploy.service
-```
-
-### Backup operations
-
-```bash
-# Take a snapshot to S3 right now (out-of-band, identical to the timer's fire).
-$ sudo systemctl start vortex-bench-backup.service
-$ journalctl -fu vortex-bench-backup.service
-
-# List recent backups in S3.
-$ aws s3 ls s3://vortex-benchmark-results-database/v3-backups/ | tail -20
-
-# Take a manually-tagged snapshot (e.g. before a risky operation).
-# The ts label must match [A-Za-z0-9_-]{1,64}; the directory must not exist.
-$ source /etc/vortex-bench.env
-$ ts=manual-$(date -u +%Y%m%dT%H%M%SZ)
-$ curl -fsS -X POST \
-    -H "Authorization: Bearer ${ADMIN_BEARER_TOKEN}" \
-    "${ADMIN_URL:-http://127.0.0.1:3001}/api/admin/snapshot?ts=${ts}"
-# Then tar + s3 cp by hand (the timer-driven path does this automatically).
-```
-
-### Pause and resume the autopilot
-
-```bash
-# Stop auto-deploys while debugging or doing a tricky manual change.
-$ sudo systemctl stop vortex-bench-deploy.timer
-# ... investigate ...
-$ sudo systemctl start vortex-bench-deploy.timer
-
-# Stop hourly backups (rarely needed - they are safe under load).
-$ sudo systemctl stop vortex-bench-backup.timer
-$ sudo systemctl start vortex-bench-backup.timer
-
-# Stop the site entirely (returns 502/connection refused to visitors).
-$ sudo systemctl stop vortex-bench-server
-$ sudo systemctl start vortex-bench-server
-```
-
-### Re-run the v2 to v3 migration
-
-`migrate.sh` stops the server, snapshots the current DB to `bench.prev-<ts>.duckdb`, runs the
-migrator, and starts the server back up. The autopilot timers are paused for the duration and
-restart on success. On failure they intentionally stay stopped (see Phase 9 for the rollback
-recipe).
-
-```bash
-$ source /etc/vortex-bench.env
-$ /var/lib/vortex-bench/ops/migrate.sh run --output "${VORTEX_BENCH_DB:-/var/lib/vortex-bench/bench.duckdb}"
-```
-
-`migrate.sh`'s positional args pass straight through to `cargo run -p vortex-bench-migrate --`, so
-the migrator's CLI is whatever the current branch says it is. As of writing it is
-`run --output <path>`.
-
-### Token rotation
-
-`INGEST_BEARER_TOKEN`:
-
-```bash
-$ openssl rand -hex 32                                     # generate new value
-# 1. Update the GitHub Actions Environment secret so CI uses the new value.
-# 2. Edit /etc/vortex-bench.env with the new value.
-$ sudo $EDITOR /etc/vortex-bench.env
-$ /var/lib/vortex-bench/ops/restart.sh                     # picks up the new env
-```
-
-`ADMIN_BEARER_TOKEN`:
-
-```bash
-$ openssl rand -hex 32                                     # generate new value
-$ sudo $EDITOR /etc/vortex-bench.env
-$ /var/lib/vortex-bench/ops/restart.sh
-# The next backup timer fire reads the env file fresh, so it picks up
-# the new value automatically.
-```
-
-The two tokens are independent. Rotating one does not affect the other.
-
-### Adding or removing an admin
-
-Being an admin is three independent grants, not a single role:
-
-```bash
-# (1) SSH access to the EC2 box.
-#     Append the new admin's public key to authorized_keys. They log in
-#     as ec2-user (which is also the service identity).
-$ sudo -u ec2-user $EDITOR /home/ec2-user/.ssh/authorized_keys
-# Or use AWS SSM Session Manager: enable on the instance and add the
-# admin's IAM principal to the instance's SSM connect IAM policy.
-
-# (2) AWS console access for IAM/lifecycle/bucket-policy changes
-#     (the runtime role intentionally cannot do these).
-#     Grant via IAM user or SSO role with read/write on IAM and the
-#     vortex-benchmark-results-database bucket.
-
-# (3) Bearer-token knowledge, if they need to hit /api/admin/* from
-#     their laptop. /etc/vortex-bench.env is mode 0600 owned by ec2-user;
-#     anyone with SSH access can read it.
-```
-
-To revoke an admin: delete their key from `authorized_keys`, revoke their AWS console role, and
-rotate `ADMIN_BEARER_TOKEN`. CI's `INGEST_BEARER_TOKEN` is unaffected because it lives in GitHub
-Actions, not on the host.
-
-### Disk pressure
-
-`/var/lib/vortex-bench/` filling up has four typical causes (see
-`du -sh /var/lib/vortex-bench/* | sort -h` to identify which):
-
-```bash
-# `bin/vortex-bench-server.<ts>.<pid>` accumulation - deploy.sh keeps the
-# last $KEEP_BINARIES (default 3). To prune harder:
-$ sudo $EDITOR /etc/vortex-bench.env                       # add KEEP_BINARIES=1
-$ /var/lib/vortex-bench/ops/force-rebuild.sh               # next deploy enforces the new cap
-
-# `snapshots/<ts>/` not deleted - backup.sh removes after a successful
-# S3 upload, so leftover dirs imply the upload failed. Check:
-$ journalctl -u vortex-bench-backup.service --since '4 hours ago'
-
-# `bench.prev-<ts>.duckdb` accumulation from old migrations. These are
-# kept on purpose for rollback. Delete by hand once verified:
-$ ls -lt /var/lib/vortex-bench/bench.prev-*.duckdb
-$ rm /var/lib/vortex-bench/bench.prev-<old-ts>.duckdb{,.wal}
-
-# `bench.duckdb` itself growing - expected, hundreds of MB is normal.
-```
-
-## What to do if a step fails
-
-| Symptom                                                                   | Likely cause                                                                   | Fix                                                                               |
-| ------------------------------------------------------------------------- | ------------------------------------------------------------------------------ | --------------------------------------------------------------------------------- |
-| `install.sh` exits with `ERROR: <ops_dir> not found. Set REPO_DIR=<repo path>.` | Running from outside the repo root or with a non-default `REPO_DIR`            | `cd ~/vortex && ./benchmarks-website/ops/install.sh`                              |
-| `journalctl -u vortex-bench-deploy` shows `Permission denied (publickey)` | `origin` is the SSH remote                                                     | `git -C ~/vortex remote set-url origin https://github.com/vortex-data/vortex.git` |
-| `journalctl -u vortex-bench-deploy` shows `cargo: command not found`      | Rust toolchain not installed for `ec2-user`                                    | Re-run Phase 2.1; the timer runs as `ec2-user`, not as you                        |
-| First `curl /health` returns connection refused                           | Deploy timer has not produced a binary yet, or the build failed                | `journalctl -fu vortex-bench-deploy.service` and read the most recent failure     |
-| `inspect.sh` returns 401 or 503                                           | `ADMIN_BEARER_TOKEN` was empty at server start, the admin listener never bound | Edit `/etc/vortex-bench.env`, `restart.sh`                                        |
-| `backup.sh` logs `/api/admin/snapshot returned 000`                       | The server is not running, or the admin port is wrong                          | `systemctl status vortex-bench-server`, check `$ADMIN_URL` in the env file        |
-| `backup.sh` logs `aws s3 cp failed`                                       | IAM role missing or wrong                                                      | Re-run Phase 1.4 to debug                                                         |
-| `migrate.sh` exits with the rollback instructions                         | The migrator itself errored, the prev DB is intact                             | Follow the printed `mv` lines literally                                           |
-| Phase 8.5 `INSTALL vortex` fails                                          | DuckDB CLI is older than the bundled engine                                    | Upgrade the CLI per Phase 8.4                                                     |
-| `deploy.sh` exits 4 (`cargo build failed`)                                | Source-tree compile error                                                      | Read the build log in `journalctl -u vortex-bench-deploy.service`; fix and push   |
-| `deploy.sh` exits 5 (`systemctl restart failed`)                          | systemd or sudoers issue                                                       | `systemctl status vortex-bench-server`; check the sudoers fragment at `/etc/sudoers.d/vortex-bench` |
-| `deploy.sh` exits 6 (`/health failed, rolled back to prior binary`)       | New binary broken; prior binary healthy                                       | Fix the source and push the next commit; the live binary is the prior good one   |
-| `deploy.sh` exits 7 (`/health failed AND rollback also broken`)           | Server is DOWN; both new and prior binaries fail /health                       | Pick a known-good binary from `/var/lib/vortex-bench/bin/`, `sudo ln -snT <chosen> /var/lib/vortex-bench/bin/vortex-bench-server`, `sudo systemctl restart vortex-bench-server` |
-
-See [`README.md`](README.md#failure-modes-conceptual) "Failure modes (conceptual)" for the full
-reference list. This file covers only the failure modes a bootstrap operator actually hits.
diff --git a/benchmarks-website/ops/README.md b/benchmarks-website/ops/README.md
deleted file mode 100644
index 80c7651b051..00000000000
--- a/benchmarks-website/ops/README.md
+++ /dev/null
@@ -1,323 +0,0 @@
-<!--
-SPDX-License-Identifier: Apache-2.0
-SPDX-FileCopyrightText: Copyright the Vortex contributors
--->
-
-# vortex-bench-server - operations runbook
-
-This is the canonical guide for deploying and operating the v3 benchmarks site (`bench.vortex.dev`)
-on EC2. It targets a fresh admin who has SSH access to the box and never seen the system before.
-
-The contents of this directory are everything the EC2 host needs to build, run, deploy, back up, and
-inspect the server. There is no out-of-tree state - every script and unit lives in
-`benchmarks-website/ops/` and gets installed onto the host by [`install.sh`](install.sh).
-
-## TL;DR
-
-- One Rust binary (`vortex-bench-server`), one DuckDB file (`/var/lib/vortex-bench/bench.duckdb`).
-- A systemd timer polls `origin/develop` every 60s. If commits in the range touch website-relevant
-  paths it builds, atomically swaps the binary, and restarts the server. Otherwise it fast-forwards
-  the working tree and exits.
-- A second timer fires hourly, asks the server to write a per-table Vortex snapshot (`schema.sql` +
-  one `<table>.vortex` per table), `tar czf`s it, and uploads to
-  `s3://vortex-benchmark-results-database/v3-backups/<UTC ts>.tar.gz`. The vortex DuckDB extension
-  is auto-installed from the DuckDB core extension repo on first call. Vortex compresses the
-  BIGINT[] runtime arrays and string columns roughly an order of magnitude better than gzipped CSV -
-  and dogfoods the project's own format.
-- For ad-hoc reads, `inspect.sh` calls a bearer-gated `/api/admin/sql` endpoint instead of stopping
-  the server.
-- For DB-replacing operations (re-running the v2→v3 migration), `migrate.sh` stops the server,
-  snapshots the current DB to `bench.prev-<ts>.duckdb`, runs the migration, and starts back up.
-
-## Architecture
-
-```
-┌──────────────────────────────────────────────────────────────────────┐
-│ EC2 host (Amazon Linux 2023, ec2-user)                               │
-│                                                                      │
-│  /home/ec2-user/vortex/         ← git checkout (build context only)  │
-│                                                                      │
-│  /var/lib/vortex-bench/                                              │
-│    bench.duckdb                 ← live DB                            │
-│    bench.duckdb.wal                                                  │
-│    bench.prev-<ts>.duckdb       ← pre-migration backup, never pruned │
-│    bin/                                                              │
-│      vortex-bench-server        ← symlink → versioned binary         │
-│      vortex-bench-server.<ts>.<pid>                                  │
-│                                   ← versioned (PID suffix breaks   │
-│                                     same-second collisions), last  │
-│                                     $KEEP_BINARIES (3)             │
-│    snapshots/<ts>/              ← transient vortex-snapshot landing  │
-│    last-deployed-sha            ← stamp file for the deploy timer    │
-│    .deploy.lock                 ← flock guard                        │
-│    ops -> /home/ec2-user/vortex/benchmarks-website/ops               │
-│                                                                      │
-│  /etc/vortex-bench.env          ← secrets, mode 0600                 │
-│  /etc/sudoers.d/vortex-bench    ← lets ec2-user systemctl restart    │
-│                                   the server with no password        │
-│  /etc/systemd/system/                                                │
-│    vortex-bench-server.service  ← serves :3000                       │
-│    vortex-bench-deploy.service  ← oneshot, runs deploy.sh            │
-│    vortex-bench-deploy.timer    ← every 60s                          │
-│    vortex-bench-backup.service  ← oneshot, runs backup.sh            │
-│    vortex-bench-backup.timer    ← hourly                             │
-│                                                                      │
-│  Logs: journalctl -u vortex-bench-{server,deploy,backup}             │
-└──────────────────────────────────────────────────────────────────────┘
-                              │
-                              │ aws s3 cp  <ts>.tar.gz
-                              ▼
-                ┌───────────────────────────────────────┐
-                │ s3://vortex-benchmark-results-database/│
-                │   v3-backups/                         │
-                │     <UTC ts>.tar.gz                   │
-                │       <UTC ts>/                       │
-                │         schema.sql                    │
-                │         <table>.vortex                │
-                └───────────────────────────────────────┘
-```
-
-## Files in this directory
-
-| Path                                                                 | Role                                                                        |
-| -------------------------------------------------------------------- | --------------------------------------------------------------------------- |
-| [`install.sh`](install.sh)                                           | One-time bootstrap on a fresh host. Idempotent.                             |
-| [`deploy.sh`](deploy.sh)                                             | Pull → build (if needed) → atomic restart. Called by timer.                 |
-| [`migrate.sh`](migrate.sh)                                           | Manual: stop, snapshot prev DB, run migrate, restart.                       |
-| [`backup.sh`](backup.sh)                                             | Hourly: trigger `/api/admin/snapshot`, sync to S3, prune local.             |
-| [`inspect.sh`](inspect.sh)                                           | Read-only SQL via `/api/admin/sql`, no server stop.                         |
-| [`force-rebuild.sh`](force-rebuild.sh)                               | Re-run a deploy of `$DEPLOY_BRANCH` even when origin hasn't moved.          |
-| [`restart.sh`](restart.sh)                                           | Restart the binary in place with visible before/after state.                |
-| [`config/vortex-bench.env.example`](config/vortex-bench.env.example) | Template for `/etc/vortex-bench.env`.                                       |
-| [`systemd/`](systemd/)                                               | Unit files installed into `/etc/systemd/system/`.                           |
-| [`BOOTSTRAP.md`](BOOTSTRAP.md)                                       | Step-by-step bootstrap and recovery runbook (copy-paste, verify-as-you-go). |
-
-**Every runnable command lives in [`BOOTSTRAP.md`](BOOTSTRAP.md).** This file explains *what* the
-system is and *why* the moving parts are shaped the way they are. Operators run commands out of
-`BOOTSTRAP.md`; the sections below are the conceptual companion you read before or after.
-
-## How the system runs
-
-### The deploy autopilot
-
-`vortex-bench-deploy.timer` fires every 60s. The service it triggers fetches `origin/$DEPLOY_BRANCH`,
-compares the tip SHA against `/var/lib/vortex-bench/last-deployed-sha`, and exits early if nothing
-moved. When the SHA has moved, the script inspects the diff against the old SHA: it only rebuilds
-when the change touches `benchmarks-website/server/`, `benchmarks-website/migrate/`,
-`benchmarks-website/Cargo.toml`, the workspace `Cargo.toml`, or `Cargo.lock`. Everything else (e.g. a
-vortex-array PR) fast-forwards the working tree so the next website change builds against fresh
-dependencies, but the running binary is left alone.
-
-When a rebuild is needed: `cargo build --release` produces a versioned binary at
-`bin/vortex-bench-server.<UTC-ts>.<pid>`, the symlink at `bin/vortex-bench-server` swings to it
-atomically, the server unit restarts, and `deploy.sh` probes `/health` for up to 30s. On any failure
-(build, restart, health check) the symlink rolls back to the previous binary and the server restarts
-on the old version. The stamp file is **not** written on a failed deploy, so the next timer fire
-retries the same SHA. Fix the bug and push again.
-
-The flock at `/var/lib/vortex-bench/.deploy.lock` serializes deploy / force-rebuild / manual-deploy
-attempts. The `force-rebuild.sh` sentinel (`.force-rebuild` under `STATE_DIR`) bypasses the path
-filter and the stamp comparison once, then deletes itself.
-
-### Identifying the running build
-
-Three identifiers should always agree on a healthy host:
-
-| Source                                                   | What it represents                                                                       |
-| -------------------------------------------------------- | ---------------------------------------------------------------------------------------- |
-| `cat /var/lib/vortex-bench/last-deployed-sha`            | What the deploy timer last successfully rolled out.                                      |
-| `readlink /var/lib/vortex-bench/bin/vortex-bench-server` | Which versioned binary the symlink points at (its filename embeds the build timestamp). |
-| `curl /health` → `.build_sha`                            | What `cargo build` saw at compile time, baked into the running process.                  |
-
-`build_sha` is the source of truth. Disagreement means the running process is stale: a manual binary
-swap, a `restart.sh` with no rebuild, or systemd holding an older pid open.
-
-### The three "restart" semantics
-
-Pick the smallest hammer:
-
-- **`restart.sh`** restarts the existing binary. Cheapest. Useful after editing
-  `/etc/vortex-bench.env` or recovering from a stuck connection. `build_sha` does not change; `pid`
-  and `started` do.
-- **Triggering the deploy service** runs the timer's normal flow now instead of waiting up to 60s.
-  No-op if `origin/$DEPLOY_BRANCH` has not moved.
-- **`force-rebuild.sh`** ignores both the stamp file and the path filter, so it rebuilds whatever's
-  on `$DEPLOY_BRANCH` even when origin has not moved. Use this when you flipped `DEPLOY_BRANCH`, are
-  recovering from wedged build artifacts, or want to redeploy "whatever is on the branch I'm
-  tracking."
-
-There is no "build whatever I have locally checked out" mode. The deploy script always builds
-origin's tip, so to test a branch you push it first.
-
-### Migration semantics
-
-The v2 to v3 migration is destructive: it overwrites `/var/lib/vortex-bench/bench.duckdb` from the v2
-source. `migrate.sh` treats this as the most dangerous operation in the system:
-
-1. Pause both autopilot timers AND interrupt any in-flight service so a deploy or backup cannot race
-   the migrator's exclusive DB access.
-2. Stop the server.
-3. Copy the current `bench.duckdb` (and any `.wal`) to `bench.prev-<UTC-ts>.duckdb` for instant
-   rollback.
-4. Run the migrator (positional args pass straight through to the `vortex-bench-migrate` CLI).
-5. Start the server, poll `/health` for up to 30s.
-6. On success, restart the autopilot timers. On **failure**, intentionally leave the autopilot
-   timers stopped and print the rollback command. The prev DB is never auto-deleted; the operator
-   removes it once they've verified the migration.
-
-This means "deploy the latest commit" and "rerun the migration" are deliberately distinct actions.
-The autopilot never touches the DB.
-
-### The backup loop
-
-`vortex-bench-backup.timer` fires hourly and `vortex-bench-backup.service` runs `backup.sh`. The
-script POSTs to the loopback-only `/api/admin/snapshot` endpoint, which writes a per-table Vortex
-snapshot (`schema.sql` plus one `<table>.vortex` per table) into
-`$VORTEX_BENCH_SNAPSHOT_DIR/<ts>/`. The script then tars and gzips that directory, uploads to
-`$S3_BACKUP_PREFIX/<ts>.tar.gz`, and deletes the local copies. The bucket lifecycle rule expires old
-objects (default 7 days, 168 hourly snapshots).
-
-Vortex compresses our shape (BIGINT[] runtime arrays + short strings) about an order of magnitude
-better than gzipped CSV, and dogfoods the project's own format. The gzip on the tarball mostly
-catches `schema.sql` and tar metadata, not the data columns themselves.
-
-`/api/admin/snapshot` requires `ts` to match `[A-Za-z0-9_-]{1,64}` and refuses to overwrite an
-existing snapshot directory (409). The same endpoint is used out-of-band before risky operations;
-just pick a label the timer can't collide with (e.g. `manual-<ts>`).
-
-### Why two listeners?
-
-The server binds two ports: a public listener (`VORTEX_BENCH_BIND`, typically `0.0.0.0:3000`) carries
-`/`, `/api/ingest`, and `/health`. A separate admin listener (`VORTEX_BENCH_ADMIN_BIND`, mandatorily
-loopback-only, `127.0.0.1:3001`) carries `/api/admin/*`. The admin listener fails to start on a
-non-loopback bind, so `/api/admin/*` cannot reach the public network even when the public bind opens
-`0.0.0.0`. Hitting `/api/admin/*` on the public listener always 404s.
-
-The admin router is mounted only when `ADMIN_BEARER_TOKEN` is set. With the env unset (e.g. local
-dev) no admin listener is bound at all, and `backup.sh` / `inspect.sh` fail fast. There is no silent
-"backups disabled" mode.
-
-### The "three grants" admin model
-
-There is no admin database. Being an admin is three independent things:
-
-1. **SSH access to the EC2 box** as `ec2-user` (the same identity systemd runs the service as).
-   Granted by adding the admin's public key to `authorized_keys`, or via AWS Systems Manager Session
-   Manager.
-2. **AWS console access** for the metadata the runtime role intentionally cannot reach (IAM, bucket
-   policy, lifecycle rules). Granted via IAM user or SSO role.
-3. **Bearer-token knowledge** for hitting `/api/admin/*` directly. Anyone with SSH access can read
-   `/etc/vortex-bench.env`, so this grant follows from grant 1.
-
-Revoking an admin therefore means revoking all three: drop the SSH key, revoke the AWS role, rotate
-`ADMIN_BEARER_TOKEN`. CI's `INGEST_BEARER_TOKEN` is unaffected because it lives in GitHub Actions,
-not on the host.
-
-## State on disk
-
-Every persistent file the system owns lives under `/var/lib/vortex-bench/` (state) or `/etc/`
-(config):
-
-| Path                                                        | Owner                           | Lifetime                                                                                |
-| ----------------------------------------------------------- | ------------------------------- | --------------------------------------------------------------------------------------- |
-| `/var/lib/vortex-bench/bench.duckdb` (+ `.wal`)             | server                          | Live data; replaced by migrate, restored from S3.                                       |
-| `/var/lib/vortex-bench/bench.prev-<ts>.duckdb`              | `migrate.sh`                    | Kept until operator deletes; rollback target.                                            |
-| `/var/lib/vortex-bench/bin/vortex-bench-server`             | `deploy.sh`                     | Symlink to current versioned binary.                                                     |
-| `/var/lib/vortex-bench/bin/vortex-bench-server.<ts>.<pid>`  | `deploy.sh`                     | Versioned binaries; last `$KEEP_BINARIES` (default 3) kept.                              |
-| `/var/lib/vortex-bench/snapshots/<ts>/`                     | `/api/admin/snapshot`           | Transient; `backup.sh` deletes after S3 upload.                                          |
-| `/var/lib/vortex-bench/last-deployed-sha`                   | `deploy.sh`                     | Stamp file; only written on success.                                                     |
-| `/var/lib/vortex-bench/.deploy.lock`                        | `deploy.sh`                     | flock serialization guard.                                                               |
-| `/var/lib/vortex-bench/duckdb-extensions/`                  | DuckDB                          | Writable extension install dir (`ProtectHome` blocks the default DuckDB path).           |
-| `/var/lib/vortex-bench/ops`                                 | `install.sh`                    | Symlink to `<repo>/benchmarks-website/ops/`.                                             |
-| `/etc/vortex-bench.env`                                     | `install.sh` then operator      | Mode 0600 owned by ec2-user; both server and timers read it.                             |
-| `/etc/sudoers.d/vortex-bench`                               | `install.sh`                    | Grants the run user `systemctl restart`/`start`/`stop` on the v3 units only.            |
-| `/etc/systemd/system/vortex-bench-*.{service,timer}`        | `install.sh`                    | The five units.                                                                          |
-
-## First-time install and disaster recovery
-
-Removed from this file. Both flows are now in [`BOOTSTRAP.md`](BOOTSTRAP.md): Phases 1 through 7 for
-a fresh install, Phases 1 through 6 then 8 for a backup-restore rebuild, Phase 9 for rolling back a
-botched migration. Each phase has a verification command so you find out immediately if a step did
-not land. Edit `BOOTSTRAP.md` (not this file) when the procedure changes.
-
-## Wire APIs the ops scripts depend on
-
-These are the only server endpoints the operator scripts touch. They also constitute the public
-admin contract for any future tooling.
-
-The server exposes two listeners. The public listener carries everything operator-facing and
-CI-facing; the admin listener stays loopback-only so `/api/admin/*` cannot reach the public network
-even when the public bind opens `0.0.0.0`.
-
-| Method + path                                                    | Bearer | Listener (env var)                              | Used by                        |
-| ---------------------------------------------------------------- | ------ | ----------------------------------------------- | ------------------------------ |
-| `GET /health`                                                    | none   | public (`$SERVER_URL`, `VORTEX_BENCH_BIND`)     | `deploy.sh` post-restart probe |
-| `POST /api/ingest`                                               | ingest | public                                          | CI dual-write                  |
-| `POST /api/admin/snapshot?ts=<id>`                               | admin  | admin (`$ADMIN_URL`, `VORTEX_BENCH_ADMIN_BIND`) | `backup.sh`                    |
-| `POST /api/admin/sql` (body `{"sql": …}`, `?format=json\|table`) | admin  | admin                                           | `inspect.sh`                   |
-
-`POST /api/admin/snapshot` writes `schema.sql` + per-table `.vortex` files; `ts` must match
-`[A-Za-z0-9_-]{1,64}` and the directory must not exist (409 otherwise). `POST /api/admin/sql` allows
-only `SELECT`/`WITH`/`PRAGMA`/`SHOW`/`DESCRIBE`/`EXPLAIN` and runs each statement inside
-`BEGIN TRANSACTION READ ONLY`.
-
-The admin router is mounted only when `ADMIN_BEARER_TOKEN` is set. With the env unset (e.g. in local
-dev) no admin listener is bound at all - `backup.sh` and `inspect.sh` fail fast against
-`$ADMIN_URL`, so there's no silent "backups disabled" mode. Hitting `/api/admin/*` on the **public**
-listener always 404s, regardless of whether admin is configured.
-
-See [`server/src/admin.rs`](../server/src/admin.rs) for the full contract and the validation rules.
-
-## Failure modes (conceptual)
-
-When something breaks, the symptom usually points at exactly one of these. For the actual diagnostic
-and repair commands, see the symptom table in
-[`BOOTSTRAP.md`](BOOTSTRAP.md#what-to-do-if-a-step-fails).
-
-- **Deploys retry the same broken SHA forever.** The stamp file is only written on success, so a
-  failing deploy attempts the same SHA on every 60s tick. Fix the bug and push, or pause the timer
-  while you investigate.
-- **`/health` is slow.** It runs six `SELECT COUNT(*)`s under the connection mutex. Over 1s during a
-  benchmark ingest window is normal; over 30s means the mutex is stuck.
-- **Disk filling under `/var/lib/vortex-bench/`.** Four culprits in order of likelihood: piled-up
-  `bench.prev-*.duckdb` from old migrations, leftover `snapshots/<ts>/` directories (backup uploads
-  failing), accumulated versioned binaries (`KEEP_BINARIES` too high), the live `bench.duckdb` itself
-  (expected to grow over time).
-- **Backups not running.** Either the timer is stopped, the IAM role is broken, or the server
-  started without `ADMIN_BEARER_TOKEN` so the admin listener never bound and `curl` to it returns
-  `000`.
-- **Migrate failed partway.** `migrate.sh` leaves the server and the autopilot timers stopped on
-  failure and prints the rollback commands on stderr. The prev DB is on local disk and complete;
-  restore it before doing anything else.
-- **Migrating to a new EC2 host.** Stand the new host up, take a final snapshot on the old host,
-  restore from S3 on the new host, cut DNS. Total RPO is bounded by the backup timer interval (one
-  hour by default).
-
-## Local development
-
-You don't need any of this to run the server locally:
-
-```bash
-INGEST_BEARER_TOKEN=dev \
-ADMIN_BEARER_TOKEN=dev \
-VORTEX_BENCH_DB=/tmp/bench.duckdb \
-cargo run -p vortex-bench-server
-```
-
-The admin endpoints work the same as in production. The hourly timer and the deploy timer are
-systemd-only - they have no local equivalent and don't need one.
-
-## What's intentionally not here
-
-- **Docker.** A previous iteration ran the server under `docker compose` with `watchtower` polling
-  GHCR. We removed it: the binary is small enough that a build-on-host model is simpler, and systemd
-  gives us atomic restarts and rollback for free. The v2 React site retains its image-based deploy
-  (separate `Dockerfile` and CI workflow); v3 does not.
-- **A push-based deploy.** A GitHub Actions workflow could push via SSM or SSH on every merge. We
-  chose polling because (a) zero inbound surface on the EC2 box, (b) no shared secret to manage in
-  CI, and (c) 60s is well under any reasonable expectation for a benchmarks site. If the polling
-  becomes unworkable, swap `vortex-bench-deploy.timer` for an SSM-triggered ExecStart and the rest
-  of `deploy.sh` doesn't change.
-- **A dedicated SQL endpoint user.** `/api/admin/sql` is gated by the same admin token as
-  `/api/admin/snapshot`. If you want per-operator audit, run a reverse proxy that adds a header and
-  log it on the way through.
diff --git a/benchmarks-website/ops/backup.sh b/benchmarks-website/ops/backup.sh
deleted file mode 100755
index dd26372f8d0..00000000000
--- a/benchmarks-website/ops/backup.sh
+++ /dev/null
@@ -1,157 +0,0 @@
-#!/usr/bin/env bash
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright the Vortex contributors
-#
-# Hourly snapshot to S3, called by vortex-bench-backup.timer.
-#
-# Asks the running server to write a per-table Vortex snapshot via
-# /api/admin/snapshot (so the writer uses the same DuckDB process
-# that owns the file - no stop required), `tar czf`s the resulting
-# directory into a single archive, uploads it to
-# $S3_BACKUP_PREFIX/<ts>.tar.gz, and deletes the local copies.
-#
-# Vortex compresses our shape (mostly BIGINT[] runtime arrays + short
-# strings) far better than gzipped CSV; the additional gzip on the
-# tarball is largely catching schema.sql and tar metadata, not the
-# data files themselves.
-#
-# The instance IAM role must already permit s3:PutObject under
-# $S3_BACKUP_PREFIX. The v3 bucket is vortex-benchmark-results-database
-# (distinct from v2's vortex-ci-benchmark-results).
-
-set -euo pipefail
-
-ENV_FILE="${ENV_FILE:-/etc/vortex-bench.env}"
-if [ ! -f "$ENV_FILE" ]; then
-    echo "ERROR: missing ${ENV_FILE}" >&2
-    exit 2
-fi
-set -a
-# shellcheck disable=SC1090
-source "$ENV_FILE"
-set +a
-: "${ADMIN_BEARER_TOKEN:?ADMIN_BEARER_TOKEN must be set in ${ENV_FILE}}"
-: "${VORTEX_BENCH_SNAPSHOT_DIR:?VORTEX_BENCH_SNAPSHOT_DIR must be set}"
-: "${S3_BACKUP_PREFIX:?S3_BACKUP_PREFIX must be set in ${ENV_FILE}}"
-# `ADMIN_URL` points at the loopback-only admin listener; `SERVER_URL`
-# stays for /health checks on the public listener.
-: "${ADMIN_URL:=http://127.0.0.1:3001}"
-: "${STATE_DIR:=/var/lib/vortex-bench}"
-: "${BACKUP_LOCK_FILE:=${STATE_DIR}/.backup.lock}"
-
-log() { printf '[backup %s] %s\n' "$(date -u +%H:%M:%SZ)" "$*"; }
-
-# Serialise against ourselves: a manual `bash backup.sh` racing the timer
-# fires would otherwise both hit /api/admin/snapshot at the same ts (the
-# server returns 409 to the loser), then both race on `rm -rf "$local_dir"`
-# while the survivor is mid-tar. Quiet bail on contention so the timer
-# journal stays clean.
-mkdir -p "$(dirname "$BACKUP_LOCK_FILE")"
-exec 200>"$BACKUP_LOCK_FILE"
-if ! flock -n 200; then
-    log "another backup is in progress; bailing"
-    exit 0
-fi
-
-ts="$(date -u +%Y%m%dT%H%M%SZ)"
-local_dir="${VORTEX_BENCH_SNAPSHOT_DIR}/${ts}"
-archive="${VORTEX_BENCH_SNAPSHOT_DIR}/${ts}.tar.gz"
-remote="${S3_BACKUP_PREFIX}/${ts}.tar.gz"
-
-# Per-PID scratch files so a manual `bash backup.sh` invocation running
-# alongside the timer-driven invocation does not clobber each other's
-# response capture or the curl auth header. Cleaned up on exit/trap.
-scratch="$(mktemp -d "${TMPDIR:-/tmp}/vortex-bench-backup.XXXXXX")"
-trap 'rm -rf "$scratch"' EXIT
-response="${scratch}/snapshot.out"
-auth_header="${scratch}/auth.hdr"
-
-# Write the Authorization header to a 0600 file and pass via `-H @path`
-# so the bearer token never appears in argv (visible to anyone reading
-# `ps aux`). Same pattern in inspect.sh. Wrap in `set +x; ...; set -x`
-# guard so an operator running `bash -x backup.sh` does not see the
-# bearer in the trace output.
-umask 077
-{ _xtrace="$(set +o | grep xtrace)"; set +x; } 2>/dev/null
-printf 'Authorization: Bearer %s\n' "${ADMIN_BEARER_TOKEN}" > "$auth_header"
-eval "$_xtrace" 2>/dev/null || true
-
-log "triggering /api/admin/snapshot?ts=${ts}"
-http_status=$(curl -sS -o "$response" -w '%{http_code}' \
-    -X POST \
-    -H "@${auth_header}" \
-    "${ADMIN_URL}/api/admin/snapshot?ts=${ts}" || echo "000")
-if [ "$http_status" != "200" ]; then
-    echo "ERROR: /api/admin/snapshot returned ${http_status}" >&2
-    cat "$response" >&2 || true
-    exit 3
-fi
-
-if [ ! -d "$local_dir" ]; then
-    echo "ERROR: server reported success but ${local_dir} does not exist" >&2
-    exit 4
-fi
-
-# Completeness check: the server writes schema.sql plus one .vortex file
-# per fact + dim table. If a deploy-timer restart interrupted the snapshot
-# write mid-stream, the directory may be partially populated; the only
-# completeness signal otherwise would be the presence of the dir, which
-# tar+s3 cp would happily pack and upload as a "valid" archive that
-# fails restore (`INSERT INTO ... silently no-op'd` per BOOTSTRAP 8.5).
-required_files=(
-    schema.sql
-    commits.vortex
-    query_measurements.vortex
-    compression_times.vortex
-    compression_sizes.vortex
-    random_access_times.vortex
-    vector_search_runs.vortex
-)
-missing=()
-for f in "${required_files[@]}"; do
-    [ -e "${local_dir}/${f}" ] || missing+=("$f")
-done
-if [ "${#missing[@]}" -gt 0 ]; then
-    echo "ERROR: snapshot ${local_dir} is incomplete; missing: ${missing[*]}" >&2
-    echo "  Most common cause: vortex-bench-server was restarted mid-snapshot." >&2
-    echo "  Leaving the partial directory in place for inspection." >&2
-    exit 4
-fi
-
-# Compress the snapshot directory into a single tar.gz. `tar -C` so paths
-# inside the archive are relative to the snapshot id (i.e. `<ts>/schema.sql`
-# and `<ts>/<table>.vortex`), which matches the layout expected by the
-# restore docs.
-log "compressing ${local_dir} → ${archive}"
-if ! tar -C "$VORTEX_BENCH_SNAPSHOT_DIR" -czf "$archive" "$ts"; then
-    echo "ERROR: tar czf failed" >&2
-    rm -f "$archive"
-    exit 5
-fi
-
-orig_bytes=$(du -sb "$local_dir" | awk '{print $1}')
-gz_bytes=$(stat -c %s "$archive")
-log "compressed ${orig_bytes} → ${gz_bytes} bytes ($(( orig_bytes / (gz_bytes > 0 ? gz_bytes : 1) ))x)"
-
-log "uploading ${archive} → s3://${remote#s3://}"
-# Retry transient `aws s3 cp` failures (rate limit / ELB blip / IAM
-# role refresh hiccup) before giving up. Backoff 2s, 8s, 30s.
-upload_ok=0
-for delay in 0 2 8 30; do
-    [ "$delay" -gt 0 ] && sleep "$delay"
-    if aws s3 cp --quiet "${archive}" "${remote}"; then
-        upload_ok=1
-        break
-    fi
-    log "aws s3 cp failed; retrying after ${delay:-0}s (next attempt)"
-done
-if [ "$upload_ok" != "1" ]; then
-    echo "ERROR: aws s3 cp failed after retries; keeping ${archive} and ${local_dir} for manual recovery" >&2
-    exit 6
-fi
-
-log "deleting local copies (${archive}, ${local_dir})"
-rm -f "$archive"
-rm -rf "$local_dir"
-
-log "snapshot ${ts} ok → ${remote}"
diff --git a/benchmarks-website/ops/config/vortex-bench.env.example b/benchmarks-website/ops/config/vortex-bench.env.example
deleted file mode 100644
index ee73097dd72..00000000000
--- a/benchmarks-website/ops/config/vortex-bench.env.example
+++ /dev/null
@@ -1,77 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright the Vortex contributors
-#
-# Template for /etc/vortex-bench.env on the EC2 host.
-#
-# install.sh copies this template into place if /etc/vortex-bench.env is
-# missing; the operator then fills in the secrets. The file must be
-# mode 0600 owned by the user systemd runs the service as (ec2-user by
-# default). systemd's EnvironmentFile= reads this for both the server
-# unit and the deploy/backup timers.
-
-# Bearer token CI presents on POST /api/ingest. Constant-time compared.
-# Generate with: openssl rand -hex 32
-INGEST_BEARER_TOKEN=
-
-# Bearer token operators present on /api/admin/snapshot and /api/admin/sql.
-# Independent of INGEST_BEARER_TOKEN so the two can rotate separately.
-# Generate with: openssl rand -hex 32
-ADMIN_BEARER_TOKEN=
-
-# DuckDB file the server opens. Lives outside any git checkout so a
-# `git pull` never touches it.
-VORTEX_BENCH_DB=/var/lib/vortex-bench/bench.duckdb
-
-# Where /api/admin/snapshot writes per-table Vortex snapshots (schema.sql
-# plus one <table>.vortex file per table). backup.sh uploads the contents
-# to S3 then deletes them, so this dir is transient.
-VORTEX_BENCH_SNAPSHOT_DIR=/var/lib/vortex-bench/snapshots
-
-# Where DuckDB installs extensions. Defaults to
-# `<VORTEX_BENCH_DB parent>/duckdb-extensions`. The systemd unit's
-# `ProtectHome=read-only` blocks DuckDB's default `~/.duckdb/extensions/...`
-# install path, so this needs to live under a writable STATE_DIR subdir.
-# Override only if you keep state outside /var/lib/vortex-bench.
-#VORTEX_BENCH_EXTENSION_DIR=/var/lib/vortex-bench/duckdb-extensions
-
-# `host:port` the *public* listener binds to (ingest, read API, HTML,
-# /health). Behind a reverse proxy (or just exposed directly on the
-# EC2 SG), 0.0.0.0 is correct.
-VORTEX_BENCH_BIND=0.0.0.0:3000
-
-# `host:port` the *admin* listener binds to. Must remain loopback-only
-# so `/api/admin/*` never reaches the public network even when
-# VORTEX_BENCH_BIND opens 0.0.0.0. backup.sh / inspect.sh talk to this
-# address via $ADMIN_URL.
-VORTEX_BENCH_ADMIN_BIND=127.0.0.1:3001
-
-# tracing-subscriber env filter spec.
-VORTEX_BENCH_LOG=info,vortex_bench_server=info
-
-# --- ops scripts only (not consumed by the server itself) --------------
-
-# Repo checkout the deploy timer pulls and builds from. Owned by the
-# same user as the systemd services so `git pull` and `cargo build` don't
-# need sudo.
-REPO_DIR=/home/ec2-user/vortex
-
-# Branch the deploy timer tracks.
-DEPLOY_BRANCH=develop
-
-# S3 prefix backup.sh syncs hourly snapshots to. The instance IAM role
-# must already permit s3:PutObject under this prefix.
-S3_BACKUP_PREFIX=s3://vortex-benchmark-results-database/v3-backups
-
-# URL of the *public* listener, used by deploy.sh's /health check.
-SERVER_URL=http://127.0.0.1:3000
-
-# URL of the *admin* listener, used by backup.sh (/api/admin/snapshot)
-# and inspect.sh (/api/admin/sql). Defaults to http://127.0.0.1:3001
-# when unset; override only if you changed VORTEX_BENCH_ADMIN_BIND.
-ADMIN_URL=http://127.0.0.1:3001
-
-# Number of versioned binaries deploy.sh keeps under $BIN_DIR after a
-# successful deploy. Defaults to 3 (current + previous + one buffer).
-# Drop to 1 during a disk-pressure incident per the ops/README.md
-# "Disk full" runbook, then bounce the deploy timer.
-#KEEP_BINARIES=3
diff --git a/benchmarks-website/ops/deploy.sh b/benchmarks-website/ops/deploy.sh
deleted file mode 100755
index 9dfd8d30442..00000000000
--- a/benchmarks-website/ops/deploy.sh
+++ /dev/null
@@ -1,332 +0,0 @@
-#!/usr/bin/env bash
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright the Vortex contributors
-#
-# Idempotent rebuild + restart, called by vortex-bench-deploy.timer
-# every 60s. Cheap and silent on the common path (no new commits).
-#
-# Flow:
-#   1. flock on a state file (concurrent runs bail).
-#   2. git fetch origin $DEPLOY_BRANCH.
-#   3. If origin SHA == last-deployed SHA → exit 0.
-#   4. Else: git diff against a path filter. If nothing in the filter
-#      changed, sync the working tree (destructive checkout) to the
-#      new SHA, update the stamp, exit 0. (Skips a build for monorepo
-#      changes that don't touch the server.)
-#   5. Else: sync working tree + cargo build --release -p vortex-bench-server.
-#   6. Compare new binary's sha256 to the currently-running symlink target.
-#      If unchanged (cargo did no real work), update stamp + exit 0.
-#   7. Else: copy to bin/vortex-bench-server.<ts>.<pid> (PID suffix
-#      breaks same-second deploy collisions), atomically swap the
-#      symlink (staging symlink + `mv -Tf` so the swap is rename(2)),
-#      sudo systemctl restart vortex-bench-server.
-#   8. Wait for /health. On failure: revert symlink, restart the prior
-#      binary, re-probe /health (so a rollback to an also-broken
-#      binary is loud), do NOT update the stamp - next tick retries.
-#   9. On success: update stamp, prune binary versions older than $KEEP_BINARIES.
-#
-# The working-tree sync is `git checkout --force --detach <sha>`, not
-# `git pull --ff-only`, so the script survives force-pushes on the
-# tracked branch.
-#
-# Exit codes:
-#   0  success (either a real deploy or a clean no-op)
-#   1  another deploy is in progress (lock held)
-#   2  config error (missing env file, REPO_DIR, etc.)
-#   3  git fetch failed
-#   4  cargo build failed
-#   5  systemctl restart failed
-#   6  /health check failed; rolled back to previous binary successfully
-#   7  /health check failed AND rollback to the previous binary ALSO
-#      failed /health - server is down, manual intervention required.
-#      This is the worst-case path; the timer will retry on next tick
-#      but the prior binary is itself broken, so the retry will not
-#      heal the host.
-
-set -euo pipefail
-
-ENV_FILE="${ENV_FILE:-/etc/vortex-bench.env}"
-STATE_DIR="${STATE_DIR:-/var/lib/vortex-bench}"
-LOCK_FILE="${LOCK_FILE:-${STATE_DIR}/.deploy.lock}"
-STAMP_FILE="${STAMP_FILE:-${STATE_DIR}/last-deployed-sha}"
-BIN_DIR="${BIN_DIR:-${STATE_DIR}/bin}"
-BIN_SYMLINK="${BIN_DIR}/vortex-bench-server"
-KEEP_BINARIES="${KEEP_BINARIES:-3}"
-
-log() { printf '[deploy %s] %s\n' "$(date -u +%H:%M:%SZ)" "$*"; }
-err() { printf '[deploy %s] ERROR: %s\n' "$(date -u +%H:%M:%SZ)" "$*" >&2; }
-
-# --- Load env ---
-if [ ! -f "$ENV_FILE" ]; then
-    err "missing ${ENV_FILE}"
-    exit 2
-fi
-set -a
-# shellcheck disable=SC1090
-source "$ENV_FILE"
-set +a
-: "${REPO_DIR:?REPO_DIR must be set in ${ENV_FILE}}"
-: "${DEPLOY_BRANCH:=develop}"
-: "${SERVER_URL:=http://127.0.0.1:3000}"
-
-if [ ! -d "${REPO_DIR}/.git" ]; then
-    err "${REPO_DIR} is not a git checkout"
-    exit 2
-fi
-
-# --- Lock ---
-mkdir -p "$(dirname "$LOCK_FILE")"
-exec 200>"$LOCK_FILE"
-if ! flock -n 200; then
-    log "another deploy is in progress; bailing"
-    exit 1
-fi
-
-# Pick up cargo from the user's profile if not on PATH already.
-# shellcheck disable=SC1091
-. "$HOME/.cargo/env" 2>/dev/null || true
-
-cd "$REPO_DIR"
-
-last_sha=""
-[ -f "$STAMP_FILE" ] && last_sha="$(cat "$STAMP_FILE")"
-
-# --- Fetch ---
-if ! git fetch --quiet origin "$DEPLOY_BRANCH"; then
-    err "git fetch origin ${DEPLOY_BRANCH} failed"
-    exit 3
-fi
-new_sha="$(git rev-parse "origin/${DEPLOY_BRANCH}")"
-
-# --- Force mode ---
-# A `FORCE=1` env var (or a `.force-rebuild` sentinel under the state
-# dir) bypasses the SHA-unchanged fast path and treats this run as if
-# nothing was ever deployed. Used by `force-rebuild.sh` for the
-# "redeploy current branch right now" path. The sentinel is consumed
-# so the next ordinary timer fire is a no-op again.
-force=0
-if [ "${FORCE:-0}" = "1" ]; then
-    force=1
-fi
-if [ -f "${STATE_DIR}/.force-rebuild" ]; then
-    rm -f "${STATE_DIR}/.force-rebuild"
-    force=1
-fi
-if [ "$force" = "1" ]; then
-    log "force mode: ignoring stamp comparison and path filter"
-    last_sha=""
-fi
-
-if [ "$force" = "0" ] && [ "$new_sha" = "$last_sha" ]; then
-    # Common case: nothing new since last fire. Silent on stdout to
-    # keep the journal clean.
-    exit 0
-fi
-
-# --- Path filter ---
-# Rebuild + restart only when commits in the range touch website code,
-# the workspace lockfile, or workspace Cargo manifests. Other changes
-# (e.g. vortex-array fixes) update the working tree but don't restart.
-filter_paths=(
-    benchmarks-website/server
-    benchmarks-website/migrate
-    Cargo.lock
-    Cargo.toml
-)
-
-if [ -z "$last_sha" ] || ! git cat-file -e "${last_sha}^{commit}" 2>/dev/null; then
-    # First run, or stamp points at a commit we no longer have. Treat
-    # as "must rebuild" so we don't silently skip a real change. Clear
-    # last_sha in the vanished-commit branch too so the hash-equal
-    # restart-skip fast path below sees an empty last_sha and forces a
-    # full restart + /health verify (the prior stamp commit being gone
-    # means we can't trust whatever the symlink currently points at).
-    log "first run / unknown stamp '${last_sha:-<empty>}'; full rebuild"
-    last_sha=""
-    relevant_changed=1
-else
-    if git diff --name-only "${last_sha}" "${new_sha}" -- "${filter_paths[@]}" | grep -q .; then
-        relevant_changed=1
-    else
-        relevant_changed=0
-    fi
-fi
-
-# --- Sync the working tree to origin/$DEPLOY_BRANCH ---
-# `git pull --ff-only` breaks the moment the tracked branch is
-# force-pushed (typical during PR iteration). The deploy worker's
-# checkout is build-only - no human edits live here - so a destructive
-# `git checkout --force --detach $new_sha` is the right semantics.
-# Detached HEAD avoids any local-branch ref drift.
-if ! git checkout --quiet --force --detach "$new_sha"; then
-    err "git checkout --force --detach ${new_sha} failed"
-    exit 3
-fi
-
-if [ "$relevant_changed" = "0" ]; then
-    log "no website-relevant paths changed in ${last_sha:0:7}..${new_sha:0:7}; skipping rebuild"
-    # Atomic stamp write so a kill mid-redirect cannot leave a truncated
-    # stamp the next tick would treat as a vanished commit.
-    printf '%s\n' "$new_sha" > "${STAMP_FILE}.tmp"
-    mv -f "${STAMP_FILE}.tmp" "$STAMP_FILE"
-    exit 0
-fi
-
-# --- Build ---
-prev_short="${last_sha:0:7}"
-log "building ${new_sha:0:7} (was ${prev_short:-<empty>})"
-if ! cargo build --release --quiet -p vortex-bench-server; then
-    err "cargo build -p vortex-bench-server failed"
-    exit 4
-fi
-new_binary="${REPO_DIR}/target/release/vortex-bench-server"
-if [ ! -x "$new_binary" ]; then
-    err "expected binary not found at ${new_binary}"
-    exit 4
-fi
-
-# --- Compare hashes; skip restart if cargo produced byte-identical output ---
-# Force mode (FORCE=1 / .force-rebuild) explicitly opts out of this fast
-# path: the operator asked for "redeploy and reverify", not "skip if the
-# byte image matches", so we must still restart + /health-poll.
-#
-# An empty last_sha (no stamp file, OR a stamp file we just rejected as
-# pointing at a vanished commit at line 130) ALSO opts out: the only
-# guarantee that the symlink's current target was health-verified comes
-# from the stamp file being present. Without it the live binary could
-# be a partially-applied prior deploy that crashed between symlink swap
-# and the restart, in which case the byte-equal path would stamp
-# success without ever restarting the server.
-new_hash="$(sha256sum "$new_binary" | awk '{print $1}')"
-current_hash=""
-if [ -L "$BIN_SYMLINK" ] && [ -e "$BIN_SYMLINK" ]; then
-    current_hash="$(sha256sum "$BIN_SYMLINK" | awk '{print $1}')"
-fi
-if [ "$force" = "0" ] && [ -n "$last_sha" ] && [ "$new_hash" = "$current_hash" ]; then
-    log "binary unchanged (sha256 ${new_hash:0:12}); skipping restart"
-    printf '%s\n' "$new_sha" > "${STAMP_FILE}.tmp"
-    mv -f "${STAMP_FILE}.tmp" "$STAMP_FILE"
-    exit 0
-fi
-
-# --- Install + atomic symlink swap ---
-# `ln -sfnT` is unlink+create - there is a brief window where $BIN_SYMLINK
-# does not exist, and a concurrent reader (e.g. systemctl restart firing
-# from another timer fire) would see ENOENT. Do the swap in two steps so
-# the final transition is `rename(2)`, which IS atomic on POSIX: create
-# the new symlink under a sibling name, then `mv -Tf` it onto $BIN_SYMLINK.
-# Same pattern is used in both rollback paths below.
-# Include a per-process suffix so two deploys within the same UTC
-# second (e.g. timer fire racing with a manual force-rebuild) cannot
-# collide on the versioned filename. Without it, the second `install`
-# would overwrite the first's binary and `prev_target` could end up
-# pointing at a path whose contents are not the prior binary anymore.
-ts="$(date -u +%Y%m%dT%H%M%SZ)"
-versioned="${BIN_DIR}/vortex-bench-server.${ts}.$$"
-install -m 0755 "$new_binary" "$versioned"
-prev_target=""
-if [ -L "$BIN_SYMLINK" ]; then
-    prev_target="$(readlink "$BIN_SYMLINK")"
-fi
-
-atomic_symlink() {
-    # $1 = symlink target, $2 = symlink path
-    local target="$1" path="$2" staging
-    staging="${path}.new.$$"
-    ln -snT -- "$target" "$staging"
-    mv -Tf -- "$staging" "$path"
-}
-
-atomic_symlink "$versioned" "$BIN_SYMLINK"
-log "swapped symlink → ${versioned}"
-
-# --- Restart + verify ---
-if ! sudo /bin/systemctl restart vortex-bench-server; then
-    err "systemctl restart failed"
-    if [ -n "$prev_target" ]; then
-        atomic_symlink "$prev_target" "$BIN_SYMLINK"
-        # Rollback restart is best-effort; the worst case (rollback ALSO
-        # failed /health) escalates to exit 7 below via the same
-        # /health re-probe used by the /health-failure path. Without
-        # the re-probe, a doubly-broken host would silently exit 5 and
-        # the next timer tick would loop on the same broken binary.
-        sudo /bin/systemctl restart vortex-bench-server || true
-        roll_deadline=$(( $(date +%s) + 30 ))
-        roll_healthy=0
-        while [ "$(date +%s)" -lt "$roll_deadline" ]; do
-            if curl -fsS --max-time 3 "${SERVER_URL}/health" >/dev/null 2>&1; then
-                roll_healthy=1
-                break
-            fi
-            sleep 1
-        done
-        if [ "$roll_healthy" = "1" ]; then
-            log "rolled back symlink to ${prev_target} (verified healthy after systemctl-restart failure)"
-            exit 5
-        fi
-        err "rollback to ${prev_target} ALSO failed /health - server is down; manual intervention required"
-        exit 7
-    fi
-    exit 5
-fi
-
-# Give it a moment to come up, then poll /health.
-deadline=$(( $(date +%s) + 30 ))
-healthy=0
-while [ "$(date +%s)" -lt "$deadline" ]; do
-    if curl -fsS --max-time 3 "${SERVER_URL}/health" >/dev/null 2>&1; then
-        healthy=1
-        break
-    fi
-    sleep 1
-done
-if [ "$healthy" != "1" ]; then
-    err "/health did not respond within 30s - rolling back"
-    if [ -n "$prev_target" ]; then
-        atomic_symlink "$prev_target" "$BIN_SYMLINK"
-        sudo /bin/systemctl restart vortex-bench-server || true
-        # Verify the rolled-back binary is itself healthy before claiming
-        # clean rollback. A "previous binary" that's also broken (e.g. a
-        # prior failed deploy nobody caught) needs a louder signal.
-        roll_deadline=$(( $(date +%s) + 30 ))
-        roll_healthy=0
-        while [ "$(date +%s)" -lt "$roll_deadline" ]; do
-            if curl -fsS --max-time 3 "${SERVER_URL}/health" >/dev/null 2>&1; then
-                roll_healthy=1
-                break
-            fi
-            sleep 1
-        done
-        if [ "$roll_healthy" = "1" ]; then
-            log "rolled back symlink to ${prev_target} (verified healthy)"
-            exit 6
-        fi
-        err "rollback to ${prev_target} ALSO failed /health - server is down; manual intervention required"
-        exit 7
-    else
-        err "no previous binary to roll back to"
-    fi
-    exit 6
-fi
-
-# --- Success: update stamp, prune old binaries ---
-printf '%s\n' "$new_sha" > "${STAMP_FILE}.tmp"
-mv -f "${STAMP_FILE}.tmp" "$STAMP_FILE"
-log "deploy ok: ${new_sha:0:7} → live (binary ${ts})"
-
-# Keep the most recent $KEEP_BINARIES versioned binaries, drop the rest.
-# Glob is restricted to the digit-prefix timestamp form so a stale staging
-# symlink (`vortex-bench-server.new.<pid>`) left over from a killed
-# `atomic_symlink` call cannot be picked up here and either inflate the
-# keep-N count or be selected for deletion as if it were an old binary.
-mapfile -t binaries < <(ls -1 "${BIN_DIR}"/vortex-bench-server.[0-9]* 2>/dev/null | sort)
-if [ "${#binaries[@]}" -gt "$KEEP_BINARIES" ]; then
-    drop_count=$(( ${#binaries[@]} - KEEP_BINARIES ))
-    for b in "${binaries[@]:0:$drop_count}"; do
-        # Never delete what the symlink currently points at.
-        if [ "$b" != "$(readlink -f "$BIN_SYMLINK")" ]; then
-            rm -f "$b"
-            log "pruned ${b}"
-        fi
-    done
-fi
diff --git a/benchmarks-website/ops/force-rebuild.sh b/benchmarks-website/ops/force-rebuild.sh
deleted file mode 100755
index 61a3e2d1363..00000000000
--- a/benchmarks-website/ops/force-rebuild.sh
+++ /dev/null
@@ -1,42 +0,0 @@
-#!/usr/bin/env bash
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright the Vortex contributors
-#
-# Force a rebuild + restart of origin/$DEPLOY_BRANCH right now, even
-# if origin hasn't moved since the last successful deploy. Drops a
-# sentinel that the next deploy.sh fire consumes, then triggers it.
-#
-# Use cases:
-#   - You changed /etc/vortex-bench.env and want a fresh binary build
-#     (e.g. a feature flag baked into config) rather than just a
-#     `systemctl restart` of the existing one.
-#   - You flipped DEPLOY_BRANCH and want the new tip in <60s rather
-#     than waiting for the timer.
-#   - Build artefacts got wedged and you want a clean rebuild.
-#
-# For "build whatever I have locally checked out" rather than fetching
-# origin, edit /etc/vortex-bench.env to point DEPLOY_BRANCH at a
-# branch the local tip is already on, then run this. The deploy
-# script always builds origin's tip - there is no "use local HEAD"
-# mode by design; push to a branch first.
-
-set -euo pipefail
-
-STATE_DIR="${STATE_DIR:-/var/lib/vortex-bench}"
-
-if [ ! -d "$STATE_DIR" ]; then
-    echo "ERROR: ${STATE_DIR} not found - has install.sh run?" >&2
-    exit 2
-fi
-
-# The sentinel file needs to be writable by the user the deploy
-# service runs as. install.sh chowns STATE_DIR to that user, so this
-# works without sudo. If you're running as a different user, sudo.
-if ! touch "${STATE_DIR}/.force-rebuild" 2>/dev/null; then
-    echo "ERROR: cannot write ${STATE_DIR}/.force-rebuild - run as the install user or sudo" >&2
-    exit 2
-fi
-
-echo "[force-rebuild] sentinel dropped; firing deploy service"
-sudo /bin/systemctl start vortex-bench-deploy.service
-echo "[force-rebuild] tail with: journalctl -fu vortex-bench-deploy.service"
diff --git a/benchmarks-website/ops/inspect.sh b/benchmarks-website/ops/inspect.sh
deleted file mode 100755
index 5362a6f5c98..00000000000
--- a/benchmarks-website/ops/inspect.sh
+++ /dev/null
@@ -1,76 +0,0 @@
-#!/usr/bin/env bash
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright the Vortex contributors
-#
-# Run a read-only SQL query against the live DuckDB without stopping
-# the server. Calls /api/admin/sql and prints the duckdb-cli-style
-# table.
-#
-# Usage:
-#   ./inspect.sh "SELECT COUNT(*) FROM commits;"
-#   echo "PRAGMA table_info('commits');" | ./inspect.sh
-#   ./inspect.sh -j "SELECT * FROM compression_sizes LIMIT 3"   # raw json
-#
-# The server allows SELECT, WITH, PRAGMA, SHOW, DESCRIBE, EXPLAIN.
-# Anything else is rejected with 403 by the server (so a typo'd UPDATE
-# can't run).
-
-set -euo pipefail
-
-ENV_FILE="${ENV_FILE:-/etc/vortex-bench.env}"
-if [ ! -f "$ENV_FILE" ]; then
-    echo "ERROR: missing ${ENV_FILE}" >&2
-    exit 2
-fi
-set -a
-# shellcheck disable=SC1090
-source "$ENV_FILE"
-set +a
-: "${ADMIN_BEARER_TOKEN:?ADMIN_BEARER_TOKEN must be set in ${ENV_FILE}}"
-# Admin SQL lives on the loopback-only admin listener; the public bind
-# (`SERVER_URL`) does not match `/api/admin/*` at all.
-: "${ADMIN_URL:=http://127.0.0.1:3001}"
-
-format=table
-if [ "${1:-}" = "-j" ] || [ "${1:-}" = "--json" ]; then
-    format=json
-    shift
-fi
-
-if [ -n "${1:-}" ]; then
-    sql="$1"
-else
-    sql="$(cat)"
-fi
-
-# Build the JSON body with `jq --arg` so quoting in the SQL is a non-issue
-# (or python3's json.dumps if jq is missing).
-if command -v jq >/dev/null 2>&1; then
-    body=$(jq -nc --arg sql "$sql" '{sql: $sql}')
-elif command -v python3 >/dev/null 2>&1; then
-    body=$(python3 -c 'import json,sys; print(json.dumps({"sql": sys.argv[1]}))' "$sql")
-else
-    echo "ERROR: install jq or python3 to call /api/admin/sql safely" >&2
-    exit 2
-fi
-
-# Write the Authorization header to a 0600 file and pass via `-H @path`
-# so the bearer token never appears in argv (visible to anyone reading
-# `ps aux`). Same pattern in backup.sh.
-scratch="$(mktemp -d "${TMPDIR:-/tmp}/vortex-bench-inspect.XXXXXX")"
-trap 'rm -rf "$scratch"' EXIT
-auth_header="${scratch}/auth.hdr"
-umask 077
-# Suppress xtrace for the one line that holds the bearer so `bash -x inspect.sh`
-# does not leak the token to stderr.
-{ _xtrace="$(set +o | grep xtrace)"; set +x; } 2>/dev/null
-printf 'Authorization: Bearer %s\n' "${ADMIN_BEARER_TOKEN}" > "$auth_header"
-eval "$_xtrace" 2>/dev/null || true
-
-curl -fsS \
-    -X POST \
-    -H "@${auth_header}" \
-    -H "Content-Type: application/json" \
-    --data-binary "$body" \
-    "${ADMIN_URL}/api/admin/sql?format=${format}"
-echo
diff --git a/benchmarks-website/ops/install.sh b/benchmarks-website/ops/install.sh
deleted file mode 100755
index 244aac4b52f..00000000000
--- a/benchmarks-website/ops/install.sh
+++ /dev/null
@@ -1,252 +0,0 @@
-#!/usr/bin/env bash
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright the Vortex contributors
-#
-# One-time bootstrap of vortex-bench-server on a fresh EC2 host.
-# Idempotent - safe to re-run after editing units or to recover from
-# partial state. See ops/README.md for the full operator runbook.
-#
-# Run as a user with sudo (typically ec2-user). The script will:
-#   1. Create state directories under /var/lib/vortex-bench, owned by
-#      $RUN_USER. Logs go to journalctl, not to a file.
-#   2. Drop a sudoers fragment that lets $RUN_USER restart the server
-#      service without a password (so the deploy timer can run as the
-#      service user).
-#   3. Copy /etc/vortex-bench.env from the template if missing (mode 0600).
-#   4. Install the systemd units and reload systemd.
-#   5. Symlink the ops/ directory into /var/lib/vortex-bench so the
-#      systemd units have a stable path (the repo can move).
-#   6. Enable + start the server, deploy timer, and backup timer.
-#
-# Usage:
-#   ./benchmarks-website/ops/install.sh
-#   REPO_DIR=$HOME/vortex ./benchmarks-website/ops/install.sh
-#
-# Only REPO_DIR is honored as an env override; the run user, state-dir,
-# env-file, systemd-dir, and sudoers-file paths are pinned (they have
-# to match the shipped systemd units, which hard-code these values).
-
-set -euo pipefail
-
-# The installed systemd units hard-code `User=ec2-user`,
-# `EnvironmentFile=/etc/vortex-bench.env`, and the
-# `/var/lib/vortex-bench` state-dir. Keep these values aligned with
-# the units in `systemd/` and the runbook in `README.md`; the script
-# does NOT template the units at install time. Anyone running on a
-# different user / state-dir / env-file path needs to hand-edit the
-# units before this script copies them into /etc/systemd/system.
-RUN_USER="ec2-user"
-RUN_GROUP="${RUN_USER}"
-REPO_DIR="${REPO_DIR:-$HOME/vortex}"
-STATE_DIR="/var/lib/vortex-bench"
-ENV_FILE="/etc/vortex-bench.env"
-SYSTEMD_DIR="/etc/systemd/system"
-SUDOERS_FILE="/etc/sudoers.d/vortex-bench"
-
-ops_dir="${REPO_DIR}/benchmarks-website/ops"
-if [ ! -d "$ops_dir" ]; then
-    echo "ERROR: ${ops_dir} not found. Set REPO_DIR=<repo path>." >&2
-    exit 2
-fi
-
-# Preflight: every external command the autopilot will call from this
-# point on. Fail loudly here with a one-line summary instead of producing
-# systemd units that 5xx silently in the journal hours later.
-missing=()
-for cmd in git cargo openssl jq flock aws tar gzip curl; do
-    command -v "$cmd" >/dev/null 2>&1 || missing+=("$cmd")
-done
-if [ "${#missing[@]}" -gt 0 ]; then
-    echo "ERROR: missing required commands: ${missing[*]}" >&2
-    echo "  (install per BOOTSTRAP.md Phase 2 before re-running install.sh)" >&2
-    exit 2
-fi
-
-# The deploy timer runs as ${RUN_USER} with no SSH agent, so an SSH
-# remote fails with "Permission denied (publickey)" on every fire.
-# Public-repo HTTPS reads need no auth - warn early so this is not the
-# first surprise out of the gate.
-if [ -d "${REPO_DIR}/.git" ]; then
-    origin_url="$(git -C "$REPO_DIR" remote get-url origin 2>/dev/null || true)"
-    case "$origin_url" in
-        git@*|ssh://*)
-            echo "WARNING: ${REPO_DIR}'s origin is ${origin_url}." >&2
-            echo "  The deploy timer cannot fetch over SSH (no agent). Fix with:" >&2
-            echo "    git -C ${REPO_DIR} remote set-url origin https://github.com/vortex-data/vortex.git" >&2
-            ;;
-    esac
-fi
-
-log() { printf '[install] %s\n' "$*"; }
-
-# --- 1. State directories ---
-log "creating ${STATE_DIR} (owner ${RUN_USER}:${RUN_GROUP})"
-sudo install -d -m 0755 -o "$RUN_USER" -g "$RUN_GROUP" \
-    "$STATE_DIR" \
-    "${STATE_DIR}/bin" \
-    "${STATE_DIR}/snapshots" \
-    "${STATE_DIR}/duckdb-extensions"
-
-# --- 2. Sudoers fragment ---
-# Let RUN_USER restart/start/stop/status the v3 systemd units without a
-# password. Scope is intentionally tight: only the four units the
-# autopilot owns, only the four verbs ops/migrate.sh and ops/deploy.sh
-# call. The other v3 admin operations (editing /etc/vortex-bench.env,
-# moving /var/lib/vortex-bench files) still require a full sudo session
-# the operator can audit.
-log "writing sudoers fragment to ${SUDOERS_FILE}"
-# Write to a tempfile, validate with visudo, ONLY THEN move into place.
-# A broken sudoers fragment in /etc/sudoers.d/ breaks sudo system-wide
-# and removes the operator's repair path; the validate-before-rename
-# pattern below makes a syntax error fail safely.
-#
-# Sudoers matches argv exactly. Each authorized invocation must be a
-# SINGLE-unit `systemctl <verb> <unit>` call; multi-unit invocations
-# (`stop A B C`) would NOT be authorized by these per-unit lines, so
-# every caller (deploy.sh, restart.sh, migrate.sh, force-rebuild.sh)
-# splits its stops/starts into one call per unit.
-sudoers_tmp="$(sudo mktemp /etc/sudoers.d/.vortex-bench.XXXXXX)"
-sudo tee "$sudoers_tmp" >/dev/null <<EOF
-# Auto-deploy + manual migration helpers run as ${RUN_USER}; only the
-# systemctl calls into the v3 units need root. Both /bin/ and /usr/bin/
-# are listed because Amazon Linux 2023 ships systemctl at /usr/bin while
-# Debian-style hosts keep the /bin compatibility symlink.
-${RUN_USER} ALL=(root) NOPASSWD: \\
-    /bin/systemctl restart vortex-bench-server, \\
-    /bin/systemctl start vortex-bench-server, \\
-    /bin/systemctl stop vortex-bench-server, \\
-    /bin/systemctl status vortex-bench-server, \\
-    /usr/bin/systemctl restart vortex-bench-server, \\
-    /usr/bin/systemctl start vortex-bench-server, \\
-    /usr/bin/systemctl stop vortex-bench-server, \\
-    /usr/bin/systemctl status vortex-bench-server, \\
-    /bin/systemctl start vortex-bench-deploy.service, \\
-    /bin/systemctl start vortex-bench-deploy.timer, \\
-    /bin/systemctl stop vortex-bench-deploy.service, \\
-    /bin/systemctl stop vortex-bench-deploy.timer, \\
-    /usr/bin/systemctl start vortex-bench-deploy.service, \\
-    /usr/bin/systemctl start vortex-bench-deploy.timer, \\
-    /usr/bin/systemctl stop vortex-bench-deploy.service, \\
-    /usr/bin/systemctl stop vortex-bench-deploy.timer, \\
-    /bin/systemctl start vortex-bench-backup.service, \\
-    /bin/systemctl start vortex-bench-backup.timer, \\
-    /bin/systemctl stop vortex-bench-backup.service, \\
-    /bin/systemctl stop vortex-bench-backup.timer, \\
-    /usr/bin/systemctl start vortex-bench-backup.service, \\
-    /usr/bin/systemctl start vortex-bench-backup.timer, \\
-    /usr/bin/systemctl stop vortex-bench-backup.service, \\
-    /usr/bin/systemctl stop vortex-bench-backup.timer
-EOF
-sudo chmod 0440 "$sudoers_tmp"
-if ! sudo visudo -cf "$sudoers_tmp" >/dev/null; then
-    sudo rm -f "$sudoers_tmp"
-    echo "ERROR: sudoers fragment failed visudo validation; refusing to install." >&2
-    exit 3
-fi
-sudo mv -f "$sudoers_tmp" "$SUDOERS_FILE"
-
-# --- 3. Env file ---
-if [ ! -f "$ENV_FILE" ]; then
-    log "creating ${ENV_FILE} from template (mode 0600 owned by ${RUN_USER})"
-    sudo install -m 0600 -o "$RUN_USER" -g "$RUN_GROUP" \
-        "${ops_dir}/config/vortex-bench.env.example" \
-        "$ENV_FILE"
-    log "EDIT ${ENV_FILE} to set INGEST_BEARER_TOKEN, ADMIN_BEARER_TOKEN, REPO_DIR"
-else
-    log "${ENV_FILE} already present - leaving alone"
-fi
-
-# --- 4. Symlink ops/ into the state dir ---
-# Gives systemd units a stable path that doesn't depend on the repo
-# checkout location moving. Stage-and-rename so the symlink is never
-# missing for a window where a concurrent timer fire's ExecStart could
-# ENOENT (matches the atomic-symlink pattern in deploy.sh).
-log "symlinking ${ops_dir} -> ${STATE_DIR}/ops"
-sudo ln -snT "$ops_dir" "${STATE_DIR}/ops.new"
-sudo mv -Tf "${STATE_DIR}/ops.new" "${STATE_DIR}/ops"
-
-# --- 5. systemd units ---
-log "installing systemd units to ${SYSTEMD_DIR}"
-for unit in \
-    vortex-bench-server.service \
-    vortex-bench-deploy.service \
-    vortex-bench-deploy.timer \
-    vortex-bench-backup.service \
-    vortex-bench-backup.timer
-do
-    sudo install -m 0644 -o root -g root \
-        "${ops_dir}/systemd/${unit}" \
-        "${SYSTEMD_DIR}/${unit}"
-done
-sudo systemctl daemon-reload
-
-# --- 6. Enable (and start, if tokens are set) ---
-# The server unit needs a binary at /var/lib/vortex-bench/bin/vortex-bench-server
-# before it can start. If the symlink isn't there yet, the deploy timer
-# will lay one down on its first run; until then the server will fail.
-if [ ! -e "${STATE_DIR}/bin/vortex-bench-server" ]; then
-    log "no binary at ${STATE_DIR}/bin/vortex-bench-server yet"
-    log "  → the first deploy-timer fire (after start) will build + install one."
-    log "  → tail it with: journalctl -fu vortex-bench-deploy.service"
-fi
-
-# Detect whether the operator has filled in the bearer tokens. An empty
-# INGEST_BEARER_TOKEN makes the server fail startup; an empty
-# ADMIN_BEARER_TOKEN leaves the admin listener unbound. Both cases mean
-# starting the units now would just produce noisy failures - enable but
-# defer the start instead. Source the env file in a subshell and test
-# the runtime values: the prior `grep '^X=.+'` heuristic matched
-# explicitly-empty `X=""` lines (the two quote characters satisfy `.+`)
-# and started units that immediately failed validate_bearer_token.
-tokens_set=$(
-    set -a
-    # shellcheck disable=SC1090
-    . "$ENV_FILE"
-    set +a
-    if [ -n "${INGEST_BEARER_TOKEN:-}" ] && [ -n "${ADMIN_BEARER_TOKEN:-}" ]; then
-        echo yes
-    fi
-)
-
-if [ "$tokens_set" = "yes" ]; then
-    log "tokens present in ${ENV_FILE} - enabling + starting deploy/backup timers"
-    # NB: we do NOT start vortex-bench-server.service here. The binary
-    # at /var/lib/vortex-bench/bin/vortex-bench-server does not exist
-    # until the deploy timer's first fire builds and installs one; the
-    # server then comes up automatically when deploy.sh runs `systemctl
-    # restart vortex-bench-server` after the symlink swap. Starting
-    # the server unit before that would just produce a noisy failure.
-    sudo systemctl enable --now vortex-bench-deploy.timer
-    sudo systemctl enable --now vortex-bench-backup.timer
-    sudo systemctl enable vortex-bench-server.service
-else
-    log "tokens not set in ${ENV_FILE} - timers enabled but not started"
-    sudo systemctl enable vortex-bench-deploy.timer
-    sudo systemctl enable vortex-bench-backup.timer
-    sudo systemctl enable vortex-bench-server.service
-    log "after editing ${ENV_FILE}, run:"
-    log "  sudo systemctl start vortex-bench-deploy.timer"
-    log "  sudo systemctl start vortex-bench-backup.timer"
-    log "  (server starts automatically on the deploy timer's first fire)"
-fi
-
-log ""
-log "install complete. Next steps:"
-log "  1. Edit ${ENV_FILE} (chmod 0600, owned by ${RUN_USER}):"
-log "     - INGEST_BEARER_TOKEN=<run 'openssl rand -hex 32' and paste>"
-log "     - ADMIN_BEARER_TOKEN=<run 'openssl rand -hex 32' and paste>"
-log "     - confirm REPO_DIR points at the actual checkout"
-log "  2. After starting the timers, watch the first deploy fire build the"
-log "     binary and bring the server up with an empty DuckDB:"
-log "       journalctl -fu vortex-bench-deploy.service"
-log "       curl http://127.0.0.1:3000/health"
-log "  3. Populate the DB with the v2 to v3 migration (server is stopped"
-log "     and restarted automatically; see BOOTSTRAP.md Phase 7.A for the"
-log "     migrator's CLI flag set):"
-log "       ${STATE_DIR}/ops/migrate.sh run --help"
-log "  4. (If preserving an existing \$HOME/bench.duckdb instead of"
-log "     re-migrating, copy it into place before step 3:"
-log "       sudo systemctl stop vortex-bench-server"
-log "       mv \$HOME/bench.duckdb ${STATE_DIR}/bench.duckdb"
-log "       sudo systemctl start vortex-bench-server"
-log "     and skip step 3.)"
diff --git a/benchmarks-website/ops/migrate.sh b/benchmarks-website/ops/migrate.sh
deleted file mode 100755
index 13ea316a36c..00000000000
--- a/benchmarks-website/ops/migrate.sh
+++ /dev/null
@@ -1,161 +0,0 @@
-#!/usr/bin/env bash
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright the Vortex contributors
-#
-# Manual v2 to v3 migration wrapper. The migration tool needs exclusive
-# access to the DB file, so the server is stopped first, the current DB
-# is snapshotted to bench.prev-<ts>.duckdb for instant rollback, the
-# migrate binary runs, and the server is started back up.
-#
-# Run from any directory while SSH'd onto the EC2 host. The args are
-# passed through verbatim to `cargo run -p vortex-bench-migrate --`, so
-# the operator owns the migrator's CLI surface (which has been changing
-# while v3 stabilises). The wrapper only handles stop / snapshot prev
-# DB / restart.
-#
-# Examples:
-#   /var/lib/vortex-bench/ops/migrate.sh run --output "$VORTEX_BENCH_DB"
-#
-# (Run as ec2-user is fine - we sudo only for systemctl.)
-
-set -euo pipefail
-
-ENV_FILE="${ENV_FILE:-/etc/vortex-bench.env}"
-if [ ! -f "$ENV_FILE" ]; then
-    echo "ERROR: missing ${ENV_FILE}" >&2
-    exit 2
-fi
-set -a
-# shellcheck disable=SC1090
-source "$ENV_FILE"
-set +a
-: "${REPO_DIR:?REPO_DIR must be set in ${ENV_FILE}}"
-: "${VORTEX_BENCH_DB:?VORTEX_BENCH_DB must be set in ${ENV_FILE}}"
-: "${SERVER_URL:=http://127.0.0.1:3000}"
-
-log() { printf '[migrate %s] %s\n' "$(date -u +%H:%M:%SZ)" "$*"; }
-
-if [ ! -d "${REPO_DIR}/.git" ]; then
-    echo "ERROR: REPO_DIR=${REPO_DIR} is not a git checkout" >&2
-    exit 2
-fi
-
-# shellcheck disable=SC1091
-. "$HOME/.cargo/env" 2>/dev/null || true
-
-# Pause the autopilot for the duration of the migration. Stopping the
-# timers alone is not enough - if deploy.service or backup.service is
-# already mid-run, the active oneshot keeps going and can restart the
-# server or call /api/admin/snapshot while the migrator owns the DB.
-# Stop the services first (interrupting any active run, idempotent
-# no-op if inactive), then the timers, then the server.
-#
-# The migration_succeeded flag is flipped to 1 only after the server
-# comes back healthy. The trap restores the autopilot on success; on
-# failure the autopilot stays paused so the operator can perform the
-# documented mv-rollback without the deploy timer trying to re-fetch
-# origin and run a fresh build on top of the half-rolled-back DB.
-migration_succeeded=0
-# The sudoers fragment install.sh writes lists each unit on its own
-# Cmnd line, and sudoers requires argv match exactly: multi-unit
-# `systemctl stop A B C D` would NOT be authorized by per-unit entries
-# and must be split into N single-unit invocations. Same on the
-# success-restore path. We deliberately do NOT use `|| true` so a real
-# sudo failure surfaces in the journal instead of silently no-op'ing the
-# autopilot pause. Install the trap BEFORE the stop calls so a partial
-# stop (one of the four sudo calls failing under set -e) still triggers
-# the restore path.
-restore_autopilot() {
-    if [ "$migration_succeeded" = "1" ]; then
-        log "restoring autopilot timers (deploy + backup)"
-        sudo /bin/systemctl start vortex-bench-deploy.timer
-        sudo /bin/systemctl start vortex-bench-backup.timer
-    else
-        log "migration did not complete - leaving autopilot timers stopped"
-        log "  inspect with: systemctl status vortex-bench-server \\"
-        log "    vortex-bench-deploy.service vortex-bench-deploy.timer \\"
-        log "    vortex-bench-backup.service vortex-bench-backup.timer"
-        log "  after rollback and verification, restart timers with:"
-        log "    sudo systemctl start vortex-bench-deploy.timer"
-        log "    sudo systemctl start vortex-bench-backup.timer"
-    fi
-}
-trap restore_autopilot EXIT
-
-log "stopping autopilot services (deploy + backup) + timers for migration window"
-sudo /bin/systemctl stop vortex-bench-deploy.timer
-sudo /bin/systemctl stop vortex-bench-deploy.service
-sudo /bin/systemctl stop vortex-bench-backup.timer
-sudo /bin/systemctl stop vortex-bench-backup.service
-
-log "stopping vortex-bench-server"
-sudo /bin/systemctl stop vortex-bench-server
-
-# Snapshot the current DB so a botched migration can be reverted with
-# one mv. WAL is folded in by DuckDB on next clean shutdown; if it
-# survives a stop, copy it too.
-ts="$(date -u +%Y%m%dT%H%M%SZ)"
-prev="${VORTEX_BENCH_DB%.duckdb}.prev-${ts}.duckdb"
-if [ -f "$VORTEX_BENCH_DB" ]; then
-    log "snapshotting ${VORTEX_BENCH_DB} → ${prev}"
-    cp -p "$VORTEX_BENCH_DB" "$prev"
-    [ -f "${VORTEX_BENCH_DB}.wal" ] && cp -p "${VORTEX_BENCH_DB}.wal" "${prev}.wal"
-fi
-
-log "running cargo run --release -p vortex-bench-migrate -- (${#} args; argv NOT logged so future flags carrying secrets do not leak to journal)"
-pushd "$REPO_DIR" >/dev/null
-# Pass through whatever args the operator gave us. Don't inject a path
-# flag - the migrator's CLI is owned by that crate.
-if ! cargo run --release --quiet -p vortex-bench-migrate -- "$@"; then
-    popd >/dev/null
-    echo "ERROR: migration failed. Server is still stopped." >&2
-    echo "  Roll back:" >&2
-    echo "    mv \"$prev\" \"$VORTEX_BENCH_DB\"" >&2
-    echo "    [ -f \"${prev}.wal\" ] && mv \"${prev}.wal\" \"${VORTEX_BENCH_DB}.wal\" || true" >&2
-    echo "  Then start the server and re-enable autopilot timers:" >&2
-    echo "    sudo systemctl start vortex-bench-server" >&2
-    echo "    sudo systemctl start vortex-bench-deploy.timer" >&2
-    echo "    sudo systemctl start vortex-bench-backup.timer" >&2
-    exit 3
-fi
-popd >/dev/null
-
-log "starting vortex-bench-server"
-sudo /bin/systemctl start vortex-bench-server
-
-# Give it a few seconds to come up.
-deadline=$(( $(date +%s) + 30 ))
-while [ "$(date +%s)" -lt "$deadline" ]; do
-    if curl -fsS --max-time 3 "${SERVER_URL}/health" >/dev/null 2>&1; then
-        migration_succeeded=1
-        log "migrate ok - server is up"
-        log "  prev DB kept at ${prev} (delete when you've verified data)"
-        exit 0
-    fi
-    sleep 1
-done
-echo "ERROR: server did not respond on /health within 30s" >&2
-# Stop the server BEFORE printing rollback instructions: the unit has
-# Restart=on-failure RestartSec=2, so leaving it running would loop a
-# broken/half-migrated binary against the new DB, and the rollback `mv`
-# below races against the still-open file handle (on Linux the mv
-# succeeds but the live server keeps writing to the unlinked inode).
-# Do NOT swallow a `systemctl stop` failure with `|| true` here: if the
-# stop fails (mid-procedure sudoers regression, systemd bus stuck), the
-# rollback `mv` below races a still-running server and the operator
-# corrupts the prev DB by following the printed instructions verbatim.
-# Bail loudly so the operator fixes the stop path before any mv.
-if ! sudo /bin/systemctl stop vortex-bench-server; then
-    echo "CRITICAL: 'sudo systemctl stop vortex-bench-server' failed." >&2
-    echo "  Do NOT execute the documented rollback 'mv' commands until the server is" >&2
-    echo "  verifiably stopped (check 'systemctl status vortex-bench-server')." >&2
-    echo "  The autopilot timers stay paused; debug the stop first." >&2
-    exit 4
-fi
-echo "  server stopped. Roll back:" >&2
-echo "    mv \"$prev\" \"$VORTEX_BENCH_DB\"" >&2
-echo "    [ -f \"${prev}.wal\" ] && mv \"${prev}.wal\" \"${VORTEX_BENCH_DB}.wal\" || true" >&2
-echo "    sudo systemctl start vortex-bench-server" >&2
-echo "    sudo systemctl start vortex-bench-deploy.timer" >&2
-echo "    sudo systemctl start vortex-bench-backup.timer" >&2
-exit 1
diff --git a/benchmarks-website/ops/restart.sh b/benchmarks-website/ops/restart.sh
deleted file mode 100755
index 290675f9597..00000000000
--- a/benchmarks-website/ops/restart.sh
+++ /dev/null
@@ -1,89 +0,0 @@
-#!/usr/bin/env bash
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright the Vortex contributors
-#
-# Restart the vortex-bench-server binary in place (no rebuild), with
-# visible before/after state so you don't have to wonder if it worked.
-#
-# Prints, in order:
-#   - the running pid + start time + binary path the symlink points at,
-#     before the restart
-#   - the systemctl exit code
-#   - the running pid + start time + /health response after the restart
-#   - "RESTART OK" / "RESTART FAILED" + non-zero exit on failure
-#
-# Use this instead of `sudo systemctl restart vortex-bench-server`
-# when you want any sign that it actually happened.
-
-set -euo pipefail
-
-ENV_FILE="${ENV_FILE:-/etc/vortex-bench.env}"
-# Source the env file first so any SERVER_URL in /etc/vortex-bench.env is
-# picked up, THEN apply the local default if both env-file and caller env
-# left it unset. (Matches the sibling scripts; replaces the prior
-# `default-then-source-then-no-op-default` shape that was misleading.)
-if [ -f "$ENV_FILE" ]; then
-    set -a
-    # shellcheck disable=SC1090
-    . "$ENV_FILE"
-    set +a
-fi
-SERVER_URL="${SERVER_URL:-http://127.0.0.1:3000}"
-
-snap() {
-    # Use systemd as the source of truth for the running pid (matches
-    # whatever it would restart). Falls back to "?" if the unit is
-    # already inactive.
-    local pid started binary health
-    pid="$(systemctl show -p MainPID --value vortex-bench-server 2>/dev/null || echo 0)"
-    started="$(systemctl show -p ActiveEnterTimestamp --value vortex-bench-server 2>/dev/null || echo '?')"
-    if [ -L /var/lib/vortex-bench/bin/vortex-bench-server ]; then
-        binary="$(readlink /var/lib/vortex-bench/bin/vortex-bench-server)"
-    else
-        binary="?"
-    fi
-    health="$(curl -fsS --max-time 2 "${SERVER_URL}/health" 2>/dev/null \
-        | (command -v jq >/dev/null && jq -c . || cat) \
-        || echo '(unreachable)')"
-    printf '  pid:        %s\n  started:    %s\n  binary:     %s\n  /health:    %s\n' \
-        "$pid" "$started" "$binary" "$health"
-}
-
-echo "BEFORE:"
-snap
-
-echo
-echo "running: sudo systemctl restart vortex-bench-server"
-if ! sudo /bin/systemctl restart vortex-bench-server; then
-    echo "ERROR: systemctl restart returned non-zero" >&2
-    echo
-    echo "AFTER (restart did not complete):"
-    snap
-    exit 1
-fi
-
-# Wait up to 30s for the new process to take requests.
-deadline=$(( $(date +%s) + 30 ))
-ok=0
-while [ "$(date +%s)" -lt "$deadline" ]; do
-    if curl -fsS --max-time 2 "${SERVER_URL}/health" >/dev/null 2>&1; then
-        ok=1
-        break
-    fi
-    sleep 0.5
-done
-
-echo
-echo "AFTER:"
-snap
-
-if [ "$ok" = "1" ]; then
-    echo
-    echo "RESTART OK"
-    exit 0
-else
-    echo
-    echo "RESTART FAILED - /health did not respond within 30s" >&2
-    echo "Inspect with: journalctl -u vortex-bench-server --since '1 min ago' --no-pager" >&2
-    exit 1
-fi
diff --git a/benchmarks-website/ops/systemd/vortex-bench-backup.service b/benchmarks-website/ops/systemd/vortex-bench-backup.service
deleted file mode 100644
index 05bd56168fa..00000000000
--- a/benchmarks-website/ops/systemd/vortex-bench-backup.service
+++ /dev/null
@@ -1,47 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright the Vortex contributors
-#
-# Oneshot unit invoked by vortex-bench-backup.timer hourly. Calls
-# /api/admin/snapshot to land a per-table Vortex snapshot (schema.sql
-# plus one <table>.vortex file per table) under
-# $VORTEX_BENCH_SNAPSHOT_DIR/<ts>/, `tar czf`s the directory into a
-# single archive, then `aws s3 cp` uploads it to
-# $S3_BACKUP_PREFIX/<ts>.tar.gz and deletes the local copies.
-#
-# PrivateTmp keeps the script's /tmp scratch (response capture) isolated
-# from any concurrent manual `bash backup.sh` an operator might fire.
-
-[Unit]
-Description=Vortex bench v3 hourly DB snapshot to S3
-After=vortex-bench-server.service network-online.target
-Wants=network-online.target
-
-[Service]
-Type=oneshot
-User=ec2-user
-Group=ec2-user
-EnvironmentFile=/etc/vortex-bench.env
-WorkingDirectory=/var/lib/vortex-bench
-ExecStart=/var/lib/vortex-bench/ops/backup.sh
-StandardOutput=journal
-StandardError=journal
-
-# Hardening - backup only needs to write snapshot scratch + tarballs in
-# the state dir and call `aws s3 cp` via the instance role.
-ProtectSystem=strict
-ReadWritePaths=/var/lib/vortex-bench
-ProtectHome=read-only
-PrivateTmp=true
-NoNewPrivileges=true
-ProtectKernelTunables=true
-ProtectKernelModules=true
-ProtectKernelLogs=true
-ProtectControlGroups=true
-RestrictNamespaces=true
-RestrictSUIDSGID=true
-RestrictAddressFamilies=AF_INET AF_INET6 AF_UNIX
-LockPersonality=true
-SystemCallFilter=@system-service
-SystemCallFilter=~@privileged @resources
-CapabilityBoundingSet=
-AmbientCapabilities=
diff --git a/benchmarks-website/ops/systemd/vortex-bench-backup.timer b/benchmarks-website/ops/systemd/vortex-bench-backup.timer
deleted file mode 100644
index 3c1910fe892..00000000000
--- a/benchmarks-website/ops/systemd/vortex-bench-backup.timer
+++ /dev/null
@@ -1,19 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright the Vortex contributors
-#
-# Hourly snapshot timer. Persistent=true means a missed hour catches up
-# after a reboot.
-
-[Unit]
-Description=Vortex bench v3 hourly DB snapshot timer
-Requires=vortex-bench-backup.service
-
-[Timer]
-# Top of every hour, UTC.
-OnCalendar=hourly
-Persistent=true
-RandomizedDelaySec=2min
-Unit=vortex-bench-backup.service
-
-[Install]
-WantedBy=timers.target
diff --git a/benchmarks-website/ops/systemd/vortex-bench-deploy.service b/benchmarks-website/ops/systemd/vortex-bench-deploy.service
deleted file mode 100644
index 2681b8a1baa..00000000000
--- a/benchmarks-website/ops/systemd/vortex-bench-deploy.service
+++ /dev/null
@@ -1,37 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright the Vortex contributors
-#
-# Oneshot unit invoked by vortex-bench-deploy.timer every 60s. Runs
-# ops/deploy.sh, which is a no-op when origin/$DEPLOY_BRANCH hasn't
-# moved or moved without touching benchmarks-website code.
-#
-# This unit deliberately runs as ec2-user - `git pull` and `cargo build`
-# don't need root. The script asks for sudo only to `systemctl restart`
-# vortex-bench-server, and the sudoers fragment ops/install.sh writes
-# allows that single command without a password.
-
-[Unit]
-Description=Vortex bench v3 auto-deploy
-# Run after the server unit is up; if the server is failing, restarting
-# it from the deploy script is what we want anyway.
-After=vortex-bench-server.service network-online.target
-Wants=network-online.target
-
-[Service]
-Type=oneshot
-User=ec2-user
-Group=ec2-user
-EnvironmentFile=/etc/vortex-bench.env
-WorkingDirectory=/var/lib/vortex-bench
-ExecStart=/var/lib/vortex-bench/ops/deploy.sh
-StandardOutput=journal
-StandardError=journal
-# Exit 1 = lock contention (another deploy is in progress). This is the
-# common steady-state outcome when a manual force-rebuild races the timer
-# fire, and is not a real failure - treat it as success so `systemctl
-# status` does not show repeated failed runs in the journal. Real
-# failures (exits 2 through 7) still surface as failed.
-SuccessExitStatus=0 1
-# Deploy runs cargo build (writes to $HOME/.cargo and $REPO_DIR/target);
-# hardening this unit beyond ec2-user privileges would break the build.
-# The narrower hardening lives on vortex-bench-server.service.
diff --git a/benchmarks-website/ops/systemd/vortex-bench-deploy.timer b/benchmarks-website/ops/systemd/vortex-bench-deploy.timer
deleted file mode 100644
index e4536e958ff..00000000000
--- a/benchmarks-website/ops/systemd/vortex-bench-deploy.timer
+++ /dev/null
@@ -1,25 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright the Vortex contributors
-#
-# Timer that fires the auto-deploy oneshot every 60s. AccuracySec=10s
-# keeps the wakeups from coalescing too aggressively; the work itself
-# is a no-op when nothing relevant changed.
-
-[Unit]
-Description=Vortex bench v3 auto-deploy timer
-Requires=vortex-bench-deploy.service
-
-[Timer]
-# Fire 30s after boot, then every 60s.
-OnBootSec=30s
-OnUnitActiveSec=60s
-AccuracySec=10s
-# Catch up after a reboot in case OnUnitActiveSec slot was missed while
-# the host was down. Matches vortex-bench-backup.timer's idiom; deploy
-# itself is idempotent (path-filter + SHA-stamp + hash-equal-skip) so
-# a missed-tick catch-up is at worst a no-op.
-Persistent=true
-Unit=vortex-bench-deploy.service
-
-[Install]
-WantedBy=timers.target
diff --git a/benchmarks-website/ops/systemd/vortex-bench-server.service b/benchmarks-website/ops/systemd/vortex-bench-server.service
deleted file mode 100644
index 8113c29f351..00000000000
--- a/benchmarks-website/ops/systemd/vortex-bench-server.service
+++ /dev/null
@@ -1,61 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright the Vortex contributors
-#
-# systemd unit for vortex-bench-server. Owns the DuckDB file at
-# $VORTEX_BENCH_DB and serves :3000.
-#
-# Installed by ops/install.sh into /etc/systemd/system/. Restart on
-# crash, never give up. Start order: after a successful binary install
-# at /var/lib/vortex-bench/bin/vortex-bench-server (the deploy timer
-# atomically swaps this symlink in place; this unit is `restart`ed via
-# the sudoers fragment ops/install.sh writes).
-
-[Unit]
-Description=Vortex bench v3 server (bench.vortex.dev)
-After=network-online.target
-Wants=network-online.target
-# A naive `systemctl start vortex-bench-server` before the deploy timer
-# has laid down a binary at the symlink would emit a confusing
-# `execve: No such file or directory` in the journal; gate on the
-# symlink so the unit reports "condition failed, not started" instead.
-ConditionPathExists=/var/lib/vortex-bench/bin/vortex-bench-server
-
-[Service]
-Type=simple
-User=ec2-user
-Group=ec2-user
-WorkingDirectory=/var/lib/vortex-bench
-EnvironmentFile=/etc/vortex-bench.env
-ExecStart=/var/lib/vortex-bench/bin/vortex-bench-server
-Restart=on-failure
-RestartSec=2
-TimeoutStopSec=60s
-# `journalctl -u vortex-bench-server` is the canonical log. Keep stdout
-# unbuffered so `tail -f` works.
-Environment=RUST_BACKTRACE=1
-StandardOutput=journal
-StandardError=journal
-
-# Conservative hardening - server only needs DB writes and outbound TCP
-# (none in steady state, but cargo build's hyper would).
-ProtectSystem=strict
-ReadWritePaths=/var/lib/vortex-bench
-ProtectHome=read-only
-PrivateTmp=true
-NoNewPrivileges=true
-ProtectKernelTunables=true
-ProtectKernelModules=true
-ProtectKernelLogs=true
-ProtectControlGroups=true
-RestrictNamespaces=true
-RestrictSUIDSGID=true
-RestrictAddressFamilies=AF_INET AF_INET6 AF_UNIX
-LockPersonality=true
-MemoryDenyWriteExecute=true
-SystemCallFilter=@system-service
-SystemCallFilter=~@privileged @resources
-CapabilityBoundingSet=
-AmbientCapabilities=
-
-[Install]
-WantedBy=multi-user.target
diff --git a/benchmarks-website/package-lock.json b/benchmarks-website/package-lock.json
index 9f195e2b553..5e1682ef02a 100644
--- a/benchmarks-website/package-lock.json
+++ b/benchmarks-website/package-lock.json
@@ -379,9 +379,9 @@
       "license": "MIT"
     },
     "node_modules/@types/react": {
-      "version": "19.2.15",
-      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.15.tgz",
-      "integrity": "sha512-eRwcGNHve+E8qtEQSSRl6urh+rFop4v8gm6O8rGv25CodbvFdLjA1vVQ1KkiFE0w0UPOnb8tDiFKL5lp0rtY5Q==",
+      "version": "19.2.17",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.17.tgz",
+      "integrity": "sha512-MXfmqaVPEVgkBT/aY0aGCkRWWtByiYQXo3xdQ8r5RzuFrPiRn8Gar2tQdXSUQ2GKV3bkXckek89V8wQBY2Q/Aw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -504,9 +504,9 @@
       }
     },
     "node_modules/concurrently": {
-      "version": "10.0.1",
-      "resolved": "https://registry.npmjs.org/concurrently/-/concurrently-10.0.1.tgz",
-      "integrity": "sha512-vN61cP9COzctyhBqKUOh9YHqU70hYPnaHqNpXdBzM9PcwIpfPAvNK06hjm4gEJEGuvy4GBairO6uU32+FKpS4g==",
+      "version": "10.0.3",
+      "resolved": "https://registry.npmjs.org/concurrently/-/concurrently-10.0.3.tgz",
+      "integrity": "sha512-hc3LH4UaKWd/bbyDK/IGVa4RB6PtQ3CUYwtrkzqHn+wIG3Hr5fhpRlk0L/gCa8ZE1L/Ufj50Zho69cI5w8SQBA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -972,9 +972,9 @@
       }
     },
     "node_modules/react": {
-      "version": "19.2.6",
-      "resolved": "https://registry.npmjs.org/react/-/react-19.2.6.tgz",
-      "integrity": "sha512-sfWGGfavi0xr8Pg0sVsyHMAOziVYKgPLNrS7ig+ivMNb3wbCBw3KxtflsGBAwD3gYQlE/AEZsTLgToRrSCjb0Q==",
+      "version": "19.2.7",
+      "resolved": "https://registry.npmjs.org/react/-/react-19.2.7.tgz",
+      "integrity": "sha512-HNe9WslTbXmFK8o8cmwgAeJFSBvt1bPdHCVKtaaV+WlAN36mpT4hcRpwbf3fY56ar2oIXzsBpOAiIRHAdY0OlQ==",
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
@@ -991,15 +991,15 @@
       }
     },
     "node_modules/react-dom": {
-      "version": "19.2.6",
-      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.6.tgz",
-      "integrity": "sha512-0prMI+hvBbPjsWnxDLxlCGyM8PN6UuWjEUCYmZhO67xIV9Xasa/r/vDnq+Xyq4Lo27g8QSbO5YzARu0D1Sps3g==",
+      "version": "19.2.7",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.7.tgz",
+      "integrity": "sha512-t0BRVXvbiE/o20Hfw669rLbMCDWtYZLvmJigy2f0MxsXF+71pxhR3xOkspmsO8h3ZlNzyibAmtCa3l4lYKk6gQ==",
       "license": "MIT",
       "dependencies": {
         "scheduler": "^0.27.0"
       },
       "peerDependencies": {
-        "react": "^19.2.6"
+        "react": "^19.2.7"
       }
     },
     "node_modules/rolldown": {
diff --git a/benchmarks-website/server.js b/benchmarks-website/server.js
index a9af96234fe..d6d3f98eef9 100644
--- a/benchmarks-website/server.js
+++ b/benchmarks-website/server.js
@@ -25,10 +25,10 @@ const USE_LOCAL_DATA = process.env.USE_LOCAL_DATA === "true";
 
 // Benchmark groups: non-query groups + simple suites + fan-out suites
 const GROUPS = [
-  "Random Access",
   "Compression",
   "Compression Size",
   ...QUERY_SUITES.filter((s) => !s.skip && !s.fanOut).map((s) => s.displayName),
+  "Random Access",
   ...FAN_OUT_GROUPS,
 ];
 
diff --git a/benchmarks-website/server/ARCHITECTURE.md b/benchmarks-website/server/ARCHITECTURE.md
deleted file mode 100644
index e790b277a46..00000000000
--- a/benchmarks-website/server/ARCHITECTURE.md
+++ /dev/null
@@ -1,87 +0,0 @@
-<!--
-SPDX-License-Identifier: Apache-2.0
-SPDX-FileCopyrightText: Copyright the Vortex contributors
--->
-
-# Benchmark Server Architecture
-
-The benchmark website is optimized around a materialized latest-100 read path.
-DuckDB is the source of truth, but normal landing-page and group-open
-hydration does not run SQL, serialize JSON, or compress responses per request.
-
-## Hot Read Path
-
-On startup the server builds a `ReadGeneration` from one DuckDB snapshot. That
-generation contains precomputed JSON artifacts for:
-
-- `/api/groups`
-- default `/api/chart/{slug}` latest-100 payloads
-- default `/api/group/{slug}` latest-100 compatibility payloads
-- versioned group shard payloads under
-  `/api/artifacts/{generation}/groups/{group_slug}/shards/{index}`
-
-Each artifact is stored in memory as identity, gzip, and brotli bytes. Request
-handlers negotiate `Accept-Encoding` and serve those bytes directly with
-`ETag`, `Vary: Accept-Encoding`, `Content-Length`, and cache headers.
-
-## Page Hydration
-
-The landing page and `/group/{slug}` render group metadata plus chart shells,
-not inline chart payloads. Each group carries the active read generation, shard
-count, and shard URL prefix. `chart-init.js` fetches shard 0 on intent or group
-open so charts paint quickly, then queues the remaining latest-100 shards with
-bounded per-tab concurrency.
-
-Latest-100 chart payloads include additive `history` metadata:
-
-- `total_commits`: full x-axis length for the chart
-- `start_index`: where this payload starts in the full x-axis
-- `loaded_commits`: number of loaded commits
-- `complete`: whether the payload covers the full x-axis
-
-The client normalizes incomplete latest-100 payloads onto the full virtual
-x-axis. Older unloaded commits are represented by blank labels and null series
-values, so the range strip, zoom limits, and slider bounds behave as if the
-whole history is present without fabricating data.
-
-## Full-History Warmup
-
-Opening a group queues `/api/chart/{slug}?n=all` for that group's charts in a
-separate low-concurrency priority queue. A later-opened group gets higher
-priority than queued work for older groups. If the user pans or zooms into an
-unloaded virtual range before warmup finishes, that chart's queued full-history
-request is promoted. In-flight requests are not cancelled.
-
-When the full payload arrives, the client replaces the virtual latest-100
-payload in place and preserves the current x-range when possible.
-
-## Fallback Paths
-
-`?n=all` and non-default `?n=` windows still use the DB-backed fallback path.
-Those reads go through `QueryCache` single-flight entries and the DB read
-semaphore so cold or unusual requests do not stampede DuckDB. Ingest writes do
-not consume read permits.
-
-## Ingest And Rebuild
-
-Successful ingest invalidates `QueryCache` and schedules a read-model rebuild.
-The active generation remains live while rebuilding. Repeated rebuild requests
-coalesce, and a failed rebuild keeps serving the old generation. The server
-keeps the active generation plus up to `RETAINED_PREVIOUS_GENERATIONS` previous
-generations (currently 8) in a bounded `VecDeque` so already loaded pages can
-continue resolving immutable shard URLs across a swap. The window is sized for
-the worst observed CI dual-write burst; under-sizing surfaces as 404s on
-`/api/artifacts/{generation}/.../shards/{i}` for stale tabs, which auto-recover
-on the next group reopen. See `RETAINED_PREVIOUS_GENERATIONS` in
-`src/read_model.rs`.
-
-## Main Files
-
-- `src/read_model.rs`: materialized generation and encoded artifact serving
-- `src/api/mod.rs`: API routing between materialized artifacts and fallbacks
-- `src/api/charts.rs`: chart DTO construction and `history` metadata
-- `src/html/mod.rs`, `src/html/landing.rs`: shell/shard HTML rendering
-- `static/chart-init.js`: virtual-axis normalization, shard hydration, and
-  full-history priority warmup
-- `src/query_cache.rs`: single-flight fallback cache
-- `src/db.rs`: DuckDB connection cloning and read backpressure
diff --git a/benchmarks-website/server/Cargo.toml b/benchmarks-website/server/Cargo.toml
deleted file mode 100644
index 8966a6fc154..00000000000
--- a/benchmarks-website/server/Cargo.toml
+++ /dev/null
@@ -1,67 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-[package]
-name = "vortex-bench-server"
-version = "0.1.0-alpha.0"
-edition = "2024"
-rust-version = "1.91.0"
-license = "Apache-2.0"
-description = "bench.vortex.dev v3 alpha server: HTTP API + HTML + DuckDB on local disk"
-publish = false
-
-[lib]
-name = "vortex_bench_server"
-path = "src/lib.rs"
-
-[[bin]]
-name = "vortex-bench-server"
-path = "src/main.rs"
-
-# This is a leaf binary, not part of the vortex-* public API surface.
-# Errors use anyhow / thiserror and the crate is intentionally outside
-# the workspace.
-
-[dependencies]
-anyhow = { workspace = true }
-axum = "0.8"
-base64 = "0.22"
-brotli = "8.0.2"
-bytes = "1.11"
-dashmap = { workspace = true }
-# track vortex-duckdb's bundled engine version (build.rs)
-duckdb = { version = "1.10502", features = ["bundled"] }
-flate2 = "1"
-futures = { workspace = true, features = ["std"] }
-maud = { version = "0.27", features = ["axum"] }
-parking_lot = { workspace = true }
-serde = { workspace = true, features = ["derive", "rc"] }
-serde_json = { workspace = true }
-subtle = "2.6"
-thiserror = { workspace = true }
-tokio = { workspace = true, features = [
-    "rt-multi-thread",
-    "macros",
-    "net",
-    "signal",
-    "sync",
-] }
-tower = "0.5"
-tower-http = { version = "0.6", features = [
-    "compression-br",
-    "compression-gzip",
-    "trace",
-] }
-tracing = { workspace = true, features = ["std"] }
-tracing-subscriber = { workspace = true, features = ["env-filter", "fmt"] }
-twox-hash = "2.1"
-vortex-utils = { workspace = true }
-
-[dev-dependencies]
-# `filters` enables `Settings::add_filter`, which we use in
-# `tests/common/mod.rs` to redact the build SHA from the HTML
-# snapshots so they don't churn on every commit.
-insta = { workspace = true, features = ["filters"] }
-reqwest = { workspace = true, features = ["json"] }
-tempfile = { workspace = true }
-tokio = { workspace = true, features = ["rt-multi-thread", "macros", "net"] }
diff --git a/benchmarks-website/server/build.rs b/benchmarks-website/server/build.rs
deleted file mode 100644
index bd6f909c752..00000000000
--- a/benchmarks-website/server/build.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::process::Command;
-
-fn main() {
-    if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("windows") {
-        println!("cargo:rustc-link-lib=dylib=rstrtmgr");
-    }
-
-    // Capture the git SHA at build time so /health can confirm the
-    // running process matches what the deploy timer last saw. Emit the
-    // full 40-hex SHA so operators can compare directly to the value
-    // in `/var/lib/vortex-bench/last-deployed-sha` (also full SHA);
-    // the runbook tells them to verify equality with no truncation.
-    // Falls back to "unknown" outside a git checkout (e.g. shallow CI
-    // clones, source tarballs) so the build never fails on this.
-    let sha = Command::new("git")
-        .args(["rev-parse", "HEAD"])
-        .output()
-        .ok()
-        .filter(|o| o.status.success())
-        .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_owned())
-        .unwrap_or_else(|| "unknown".to_owned());
-    println!("cargo:rustc-env=VORTEX_BENCH_BUILD_SHA={sha}");
-
-    // HEAD covers the common deploy.sh path
-    // (`git checkout --force --detach <sha>`); refs/heads/* covers
-    // local branches if anyone runs the binary from a checked-out
-    // branch. Both are no-ops if the file doesn't exist.
-    println!("cargo:rerun-if-changed=../../.git/HEAD");
-    println!("cargo:rerun-if-changed=../../.git/refs/heads");
-}
diff --git a/benchmarks-website/server/fixtures/envelope.json b/benchmarks-website/server/fixtures/envelope.json
deleted file mode 100644
index 14861f54a3c..00000000000
--- a/benchmarks-website/server/fixtures/envelope.json
+++ /dev/null
@@ -1,71 +0,0 @@
-{
-  "run_meta": {
-    "benchmark_id": "fixture",
-    "schema_version": 1,
-    "started_at": "2026-04-25T00:00:00Z"
-  },
-  "commit": {
-    "sha": "0123456789abcdef0123456789abcdef01234567",
-    "timestamp": "2026-04-25T00:00:00Z",
-    "message": "fixture commit",
-    "author_name": "Test Author",
-    "author_email": "author@example.com",
-    "committer_name": "Test Committer",
-    "committer_email": "committer@example.com",
-    "tree_sha": "fedcba9876543210fedcba9876543210fedcba98",
-    "url": "https://github.com/vortex-data/vortex/commit/0123456789abcdef0123456789abcdef01234567"
-  },
-  "records": [
-    {
-      "kind": "query_measurement",
-      "commit_sha": "0123456789abcdef0123456789abcdef01234567",
-      "dataset": "tpch",
-      "scale_factor": "1",
-      "query_idx": 1,
-      "storage": "nvme",
-      "engine": "datafusion",
-      "format": "vortex-file-compressed",
-      "value_ns": 1234567,
-      "all_runtimes_ns": [1200000, 1234567, 1300000],
-      "env_triple": "x86_64-linux-gnu"
-    },
-    {
-      "kind": "compression_time",
-      "commit_sha": "0123456789abcdef0123456789abcdef01234567",
-      "dataset": "tpch-lineitem",
-      "format": "vortex-file-compressed",
-      "op": "encode",
-      "value_ns": 9999,
-      "all_runtimes_ns": [9000, 9999, 10500]
-    },
-    {
-      "kind": "compression_size",
-      "commit_sha": "0123456789abcdef0123456789abcdef01234567",
-      "dataset": "tpch-lineitem",
-      "format": "vortex-file-compressed",
-      "value_bytes": 4242
-    },
-    {
-      "kind": "random_access_time",
-      "commit_sha": "0123456789abcdef0123456789abcdef01234567",
-      "dataset": "taxi",
-      "format": "vortex-file-compressed",
-      "value_ns": 555,
-      "all_runtimes_ns": [500, 555, 600]
-    },
-    {
-      "kind": "vector_search_run",
-      "commit_sha": "0123456789abcdef0123456789abcdef01234567",
-      "dataset": "cohere-large-10m",
-      "layout": "partitioned",
-      "flavor": "vortex-turboquant",
-      "threshold": 0.75,
-      "value_ns": 7777,
-      "all_runtimes_ns": [7700, 7777, 7800],
-      "matches": 42,
-      "rows_scanned": 1000000,
-      "bytes_scanned": 5000000,
-      "iterations": 3
-    }
-  ]
-}
diff --git a/benchmarks-website/server/src/admin.rs b/benchmarks-website/server/src/admin.rs
deleted file mode 100644
index 0273d61468b..00000000000
--- a/benchmarks-website/server/src/admin.rs
+++ /dev/null
@@ -1,763 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Admin endpoints - bearer-gated DuckDB snapshot and read-only SQL.
-//!
-//! Mounted at `/api/admin/*` only when `ADMIN_BEARER_TOKEN` is set on the
-//! server, surfaced through [`crate::app::AppState::with_admin`]. Both routes
-//! require an `Authorization: Bearer <ADMIN_BEARER_TOKEN>` header - the
-//! `INGEST_BEARER_TOKEN` will not work here, so the two can rotate
-//! independently. The operator workflow is documented in
-//! `benchmarks-website/ops/README.md`.
-//!
-//! ## Routes
-//!
-//! ### `POST /api/admin/snapshot?ts=<id>`
-//!
-//! Writes a snapshot directory `<snapshot_dir>/<ts>/` containing:
-//! - `schema.sql` - concatenated DDL ([`crate::schema::COMMITS_DDL`] plus
-//!   every [`crate::family::FAMILIES`] entry's `schema_ddl`), so a
-//!   restore knows how to recreate the tables before bulk-loading.
-//! - `<table>.vortex` for every table in [`crate::schema::TABLES`] -
-//!   each produced by a `COPY (SELECT * FROM <table>) TO …
-//!   (FORMAT vortex)`. The vortex DuckDB extension is auto-installed
-//!   from the DuckDB core extension repo on first call, then `LOAD`ed.
-//!
-//! Vortex compresses the BIGINT[] runtime arrays and string columns
-//! roughly an order of magnitude better than gzipped CSV on this shape;
-//! it is also the project's own format, which is the obvious dogfood.
-//!
-//! `ts` must match `[A-Za-z0-9_-]{1,64}`; the snapshot script
-//! conventionally passes a UTC timestamp like `20260508T010000Z`. The
-//! target subdirectory must not already exist (409 otherwise). All
-//! per-table COPY statements run on a connection cloned from the
-//! shared handle, so concurrent ingest writes are not blocked.
-//!
-//! ### `POST /api/admin/sql`
-//!
-//! Body: `{ "sql": "SELECT ..." }`. Query: `?format=json|table` (default
-//! `json`). Only `SELECT`, `WITH`, `PRAGMA`, `SHOW`, `DESCRIBE`, and
-//! `EXPLAIN` statements are allowed - anything else is rejected with 403.
-//! Results are capped at `ADMIN_SQL_ROW_LIMIT` rows; responses past
-//! that cap include `"truncated": true`. The handler runs each query on
-//! its own cloned connection inside a `BEGIN TRANSACTION READ ONLY`
-//! wrapper, so concurrent ingest writes proceed without contention.
-
-use std::fmt::Write as _;
-use std::path::Path;
-use std::path::PathBuf;
-use std::sync::atomic::AtomicU64;
-use std::sync::atomic::Ordering;
-
-use anyhow::Context as _;
-use anyhow::Result;
-use axum::Json;
-use axum::extract::Query;
-use axum::extract::Request;
-use axum::extract::State;
-use axum::http::StatusCode;
-use axum::http::header::AUTHORIZATION;
-use axum::http::header::CONTENT_TYPE;
-use axum::middleware::Next;
-use axum::response::IntoResponse;
-use axum::response::Response;
-use duckdb::Connection;
-use duckdb::types::ValueRef;
-use serde::Deserialize;
-use serde::Serialize;
-use serde_json::Value;
-use serde_json::json;
-use subtle::ConstantTimeEq;
-use thiserror::Error;
-
-use crate::app::AppState;
-use crate::db;
-use crate::family;
-use crate::schema;
-
-const ADMIN_SQL_ROW_LIMIT: usize = 10_000;
-
-/// Errors surfaced by `/api/admin/*` handlers. Auth (401) is handled by
-/// [`require_admin_bearer`] and never reaches a handler.
-#[derive(Debug, Error)]
-pub enum AdminError {
-    /// 400 - request shape is malformed (bad `ts`, bad SQL JSON body, …).
-    #[error("bad request: {0}")]
-    BadRequest(String),
-    /// 403 - request is well-formed but the SQL statement is not on the
-    /// read-only allow-list.
-    #[error("forbidden: {0}")]
-    Forbidden(String),
-    /// 409 - snapshot target directory already exists.
-    #[error("conflict: {0}")]
-    Conflict(String),
-    /// 500 - anything else (DB error, IO error, …).
-    #[error("internal server error")]
-    Internal(#[from] anyhow::Error),
-}
-
-impl IntoResponse for AdminError {
-    fn into_response(self) -> Response {
-        let (status, body) = match &self {
-            Self::BadRequest(msg) => (
-                StatusCode::BAD_REQUEST,
-                json!({ "error": "bad_request", "message": msg }),
-            ),
-            Self::Forbidden(msg) => (
-                StatusCode::FORBIDDEN,
-                json!({ "error": "forbidden", "message": msg }),
-            ),
-            Self::Conflict(msg) => (
-                StatusCode::CONFLICT,
-                json!({ "error": "conflict", "message": msg }),
-            ),
-            Self::Internal(err) => {
-                tracing::error!(error = ?err, "admin internal error");
-                (
-                    StatusCode::INTERNAL_SERVER_ERROR,
-                    json!({ "error": "internal" }),
-                )
-            }
-        };
-        (status, Json(body)).into_response()
-    }
-}
-
-/// Axum middleware enforcing the admin bearer token on `/api/admin/*`.
-/// 401 if the header is missing, malformed, or wrong; 503 if the server
-/// was started without `ADMIN_BEARER_TOKEN` (the admin router is unmounted
-/// in that case, so this is just a defensive belt-and-braces check).
-pub async fn require_admin_bearer(
-    State(state): State<AppState>,
-    req: Request,
-    next: Next,
-) -> Result<Response, Response> {
-    let Some(expected) = state.admin_bearer_token.as_ref() else {
-        return Err((
-            StatusCode::SERVICE_UNAVAILABLE,
-            Json(json!({ "error": "admin_not_configured" })),
-        )
-            .into_response());
-    };
-    let unauthorized = || {
-        (
-            StatusCode::UNAUTHORIZED,
-            Json(json!({ "error": "unauthorized" })),
-        )
-            .into_response()
-    };
-    let header = req
-        .headers()
-        .get(AUTHORIZATION)
-        .ok_or_else(unauthorized)?
-        .to_str()
-        .map_err(|_| unauthorized())?;
-    let presented = header
-        .strip_prefix("Bearer ")
-        .ok_or_else(unauthorized)?
-        .as_bytes();
-    if presented.ct_eq(expected.as_bytes()).into() {
-        Ok(next.run(req).await)
-    } else {
-        Err(unauthorized())
-    }
-}
-
-#[derive(Debug, Deserialize)]
-pub struct SnapshotQuery {
-    /// Operator-supplied identifier for the snapshot, used as the leaf
-    /// directory name. Must match `[A-Za-z0-9_-]{1,64}`.
-    pub ts: String,
-}
-
-#[derive(Debug, Serialize)]
-pub struct SnapshotResponse {
-    /// Absolute path of the directory the export landed in.
-    pub snapshot_dir: String,
-}
-
-/// Handler for `POST /api/admin/snapshot?ts=<id>`. Writes
-/// `schema.sql` plus one `<table>.vortex` file per fact/dim table into
-/// a fresh subdirectory under [`AppState::snapshot_dir`].
-pub async fn snapshot(
-    State(state): State<AppState>,
-    Query(q): Query<SnapshotQuery>,
-) -> Result<impl IntoResponse, AdminError> {
-    validate_ts(&q.ts)?;
-    let target: PathBuf = state.snapshot_dir.join(&q.ts);
-
-    // Process-local `ts` reservation. Two concurrent calls with the
-    // same `ts` would otherwise both write tmp directories and then
-    // race at the `rename(2)` step - Linux silently overwrites an
-    // existing destination, so the loser's snapshot disappears with no
-    // signal. The reservation closes that race within a single
-    // `vortex-bench-server` process (the supported deployment).
-    let _ticket = SnapshotTicket::acquire(&state, &q.ts, &target)?;
-
-    if target.exists() {
-        return Err(AdminError::Conflict(format!(
-            "snapshot directory already exists: {}",
-            target.display()
-        )));
-    }
-
-    let tmp = tmp_snapshot_dir(&target, &q.ts);
-    if tmp.exists() {
-        std::fs::remove_dir_all(&tmp)
-            .with_context(|| format!("removing stale temp snapshot dir {}", tmp.display()))?;
-    }
-    std::fs::create_dir_all(&tmp)
-        .with_context(|| format!("creating temp snapshot dir {}", tmp.display()))?;
-
-    let result = write_snapshot(&state, &tmp).await;
-    if let Err(err) = result {
-        cleanup_partial(&tmp);
-        return Err(AdminError::Internal(err));
-    }
-    // The ticket guarantees no other in-process call has the same `ts`
-    // reserved, so the final `rename(2)` will land cleanly. We still
-    // recheck `target.exists()` because a different process or an
-    // operator hand-creating the dir would also lose data on a silent
-    // overwrite.
-    if target.exists() {
-        cleanup_partial(&tmp);
-        return Err(AdminError::Conflict(format!(
-            "snapshot directory already exists: {}",
-            target.display()
-        )));
-    }
-    if let Err(err) = std::fs::rename(&tmp, &target).with_context(|| {
-        format!(
-            "moving snapshot dir {} to {}",
-            tmp.display(),
-            target.display()
-        )
-    }) {
-        cleanup_partial(&tmp);
-        return Err(AdminError::Internal(err));
-    }
-    Ok(Json(SnapshotResponse {
-        snapshot_dir: target.display().to_string(),
-    }))
-}
-
-/// RAII guard that holds a `ts` in [`AppState::pending_snapshots`] for the
-/// duration of one `/api/admin/snapshot` call. Dropping the guard always
-/// releases the reservation, even on panic or early-return error paths.
-struct SnapshotTicket {
-    state: AppState,
-    ts: String,
-}
-
-impl SnapshotTicket {
-    fn acquire(state: &AppState, ts: &str, target: &Path) -> Result<Self, AdminError> {
-        let inserted = state.pending_snapshots.lock().insert(ts.to_string());
-        if !inserted {
-            return Err(AdminError::Conflict(format!(
-                "snapshot for ts={ts} is already in flight (target {})",
-                target.display()
-            )));
-        }
-        Ok(Self {
-            state: state.clone(),
-            ts: ts.to_string(),
-        })
-    }
-}
-
-impl Drop for SnapshotTicket {
-    fn drop(&mut self) {
-        self.state.pending_snapshots.lock().remove(&self.ts);
-    }
-}
-
-/// Best-effort cleanup of a partially-written snapshot tmp dir. Logs the
-/// failure rather than silently discarding it, so a wedge (disk full,
-/// permission flip) is visible in the journal even when no automated
-/// sweeper is wired up.
-fn cleanup_partial(path: &Path) {
-    if let Err(err) = std::fs::remove_dir_all(path) {
-        // ENOENT just means the dir never got created or was already
-        // cleaned up by a sibling caller; ignore it. Anything else
-        // deserves a warn.
-        if err.kind() != std::io::ErrorKind::NotFound {
-            tracing::warn!(
-                path = %path.display(),
-                error = ?err,
-                "failed to clean up partial snapshot tmp dir; manual sweep may be needed"
-            );
-        }
-    }
-}
-
-/// Per-call unique temp directory used to stage a snapshot before the atomic
-/// rename onto `target`. Includes a process-local counter so two concurrent
-/// calls with the same `ts` in the same server process never share a staging
-/// directory and clobber each other's in-progress writes.
-fn tmp_snapshot_dir(target: &Path, ts: &str) -> PathBuf {
-    static COUNTER: AtomicU64 = AtomicU64::new(0);
-    let id = COUNTER.fetch_add(1, Ordering::Relaxed);
-    target.with_file_name(format!("{ts}.tmp-{}-{}", std::process::id(), id))
-}
-
-async fn write_snapshot(state: &AppState, target: &Path) -> Result<()> {
-    // Schema is just our DDL string verbatim; restore reads this with
-    // `duckdb -init schema.sql` (or `.read schema.sql`) before
-    // bulk-loading the per-table vortex files. The DDL is assembled
-    // from the commits dim + every fact-table family in the same order
-    // `db::open()` applies them.
-    let mut schema_sql = String::with_capacity(8 * 1024);
-    schema_sql.push_str(schema::COMMITS_DDL);
-    for fam in family::FAMILIES {
-        schema_sql.push_str(fam.schema_ddl);
-    }
-    std::fs::write(target.join("schema.sql"), schema_sql)
-        .with_context(|| format!("writing schema.sql under {}", target.display()))?;
-
-    let target_for_db = target.to_path_buf();
-    db::run_blocking(&state.db, move |conn| {
-        export_snapshot_tables(conn, &target_for_db)
-    })
-    .await
-}
-
-fn export_snapshot_tables(conn: &mut Connection, target: &Path) -> Result<()> {
-    // Idempotent - `INSTALL` is a no-op if the extension is already
-    // present, `LOAD` is cheap once the binary is on disk. Vortex is a
-    // DuckDB core extension (not community), so the unqualified `INSTALL`
-    // hits the right repo on first call; subsequent calls are local.
-    // Runs outside the snapshot transaction because extension installation
-    // is not transactional.
-    conn.execute_batch("INSTALL vortex; LOAD vortex;")
-        .context("INSTALL/LOAD vortex extension")?;
-
-    // All per-table COPYs share one `READ ONLY` transaction. Otherwise an
-    // ingest commit between the `commits` export and the
-    // `query_measurements` export yields an inconsistent backup - facts
-    // referencing a commit row that is not in the snapshot, or vice
-    // versa. The transaction's READ ONLY guard also belts-and-braces
-    // against the snapshot path accidentally writing.
-    conn.execute_batch("BEGIN TRANSACTION READ ONLY")
-        .context("begin read-only snapshot transaction")?;
-    if let Err(err) = copy_each_table(conn, target) {
-        if let Err(rb_err) = conn.execute_batch("ROLLBACK") {
-            tracing::warn!(
-                error = ?rb_err,
-                "rolling back snapshot read-only transaction failed; the original \
-                 export error (returned to the caller) is the actionable one"
-            );
-        }
-        return Err(err);
-    }
-    conn.execute_batch("COMMIT")
-        .context("commit read-only snapshot transaction")?;
-    Ok(())
-}
-
-fn copy_each_table(conn: &Connection, target: &Path) -> Result<()> {
-    for table in schema::TABLES.iter() {
-        let path = target.join(format!("{table}.vortex"));
-        let path_str = path
-            .to_str()
-            .ok_or_else(|| anyhow::anyhow!("snapshot path is not UTF-8: {}", path.display()))?;
-        let sql = format!(
-            "COPY (SELECT * FROM {table}) TO {} (FORMAT vortex)",
-            db::sql_string_literal(path_str)
-        );
-        conn.execute_batch(&sql)
-            .with_context(|| format!("COPY {table} TO {path_str}"))?;
-    }
-    Ok(())
-}
-
-fn validate_ts(ts: &str) -> Result<(), AdminError> {
-    if ts.is_empty() || ts.len() > 64 {
-        return Err(AdminError::BadRequest("ts must be 1..=64 chars".into()));
-    }
-    if !ts
-        .chars()
-        .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_')
-    {
-        return Err(AdminError::BadRequest(
-            "ts must match [A-Za-z0-9_-]+".into(),
-        ));
-    }
-    Ok(())
-}
-
-#[derive(Debug, Deserialize)]
-pub struct SqlBody {
-    pub sql: String,
-}
-
-#[derive(Debug, Deserialize, Default)]
-pub struct SqlQuery {
-    #[serde(default)]
-    pub format: SqlFormat,
-}
-
-#[derive(Debug, Deserialize, Default, Clone, Copy)]
-#[serde(rename_all = "lowercase")]
-pub enum SqlFormat {
-    /// Returns `{ columns, rows, row_count }` JSON.
-    #[default]
-    Json,
-    /// Returns a `text/plain` ASCII table similar to `duckdb` CLI output.
-    Table,
-}
-
-/// Handler for `POST /api/admin/sql`.
-pub async fn sql(
-    State(state): State<AppState>,
-    Query(q): Query<SqlQuery>,
-    Json(body): Json<SqlBody>,
-) -> Result<Response, AdminError> {
-    validate_read_only(&body.sql)?;
-    let format = q.format;
-    let sql_text = body.sql;
-    let result = db::run_blocking(&state.db, move |conn| run_select(conn, &sql_text))
-        .await
-        .map_err(AdminError::Internal)?;
-    Ok(match format {
-        SqlFormat::Json => Json(json!({
-            "columns": result.columns,
-            "rows": result.rows,
-            "row_count": result.rows.len(),
-            "truncated": result.truncated,
-        }))
-        .into_response(),
-        SqlFormat::Table => (
-            [(CONTENT_TYPE, "text/plain; charset=utf-8")],
-            format_table(&result),
-        )
-            .into_response(),
-    })
-}
-
-/// Strips leading whitespace, parens, semicolons, and SQL comments (both `--`
-/// line comments and `/* ... */` block comments) from `sql`. Returns the byte
-/// offset of the first non-comment, non-whitespace token. Used by
-/// [`validate_read_only`] so a query like `-- justify the call\nSELECT 1` is
-/// not rejected with `only [...] are allowed; got ""`.
-fn skip_leading_noise(sql: &str) -> usize {
-    let bytes = sql.as_bytes();
-    let mut i = 0;
-    while i < bytes.len() {
-        let b = bytes[i];
-        if b == b' ' || b == b'\t' || b == b'\n' || b == b'\r' || b == b'(' || b == b';' {
-            i += 1;
-            continue;
-        }
-        if b == b'-' && i + 1 < bytes.len() && bytes[i + 1] == b'-' {
-            // Line comment runs to end of line.
-            i += 2;
-            while i < bytes.len() && bytes[i] != b'\n' {
-                i += 1;
-            }
-            continue;
-        }
-        if b == b'/' && i + 1 < bytes.len() && bytes[i + 1] == b'*' {
-            // Block comment, search for the matching `*/`.
-            i += 2;
-            while i + 1 < bytes.len() && !(bytes[i] == b'*' && bytes[i + 1] == b'/') {
-                i += 1;
-            }
-            if i + 1 < bytes.len() {
-                i += 2;
-            } else {
-                // Unterminated block comment; let the SQL parser surface
-                // the error rather than guessing.
-                return i;
-            }
-            continue;
-        }
-        break;
-    }
-    i
-}
-
-fn validate_read_only(sql: &str) -> Result<(), AdminError> {
-    ensure_single_statement(sql)?;
-    let start = skip_leading_noise(sql);
-    let first_word: String = sql[start..]
-        .chars()
-        .take_while(|c| c.is_ascii_alphabetic())
-        .collect::<String>()
-        .to_ascii_uppercase();
-    const ALLOWED: &[&str] = &["SELECT", "WITH", "PRAGMA", "SHOW", "DESCRIBE", "EXPLAIN"];
-    if !ALLOWED.contains(&first_word.as_str()) {
-        return Err(AdminError::Forbidden(format!(
-            "only {ALLOWED:?} statements are allowed; got {first_word:?}"
-        )));
-    }
-    Ok(())
-}
-
-fn ensure_single_statement(sql: &str) -> Result<(), AdminError> {
-    #[derive(Clone, Copy, PartialEq, Eq)]
-    enum State {
-        Normal,
-        SingleQuote,
-        DoubleQuote,
-        LineComment,
-        BlockComment,
-    }
-
-    let mut state = State::Normal;
-    let mut chars = sql.char_indices().peekable();
-    while let Some((idx, ch)) = chars.next() {
-        match state {
-            State::Normal => match ch {
-                '\'' => state = State::SingleQuote,
-                '"' => state = State::DoubleQuote,
-                '-' if chars.peek().is_some_and(|(_, next)| *next == '-') => {
-                    chars.next();
-                    state = State::LineComment;
-                }
-                '/' if chars.peek().is_some_and(|(_, next)| *next == '*') => {
-                    chars.next();
-                    state = State::BlockComment;
-                }
-                ';' => {
-                    // Allow trailing whitespace and SQL comments after the
-                    // terminator (`SELECT 1; -- note` and `SELECT 1; /* a */`
-                    // are valid single statements). Only error if a
-                    // non-comment, non-whitespace token follows.
-                    let suffix_start = idx + ch.len_utf8();
-                    let after = skip_leading_noise(&sql[suffix_start..]);
-                    if !sql[suffix_start + after..].is_empty() {
-                        return Err(AdminError::Forbidden(
-                            "admin SQL accepts a single statement only".into(),
-                        ));
-                    }
-                    return Ok(());
-                }
-                _ => {}
-            },
-            State::SingleQuote => {
-                if ch == '\'' {
-                    if chars.peek().is_some_and(|(_, next)| *next == '\'') {
-                        chars.next();
-                    } else {
-                        state = State::Normal;
-                    }
-                }
-            }
-            State::DoubleQuote => {
-                if ch == '"' {
-                    if chars.peek().is_some_and(|(_, next)| *next == '"') {
-                        chars.next();
-                    } else {
-                        state = State::Normal;
-                    }
-                }
-            }
-            State::LineComment => {
-                if ch == '\n' {
-                    state = State::Normal;
-                }
-            }
-            State::BlockComment => {
-                if ch == '*' && chars.peek().is_some_and(|(_, next)| *next == '/') {
-                    chars.next();
-                    state = State::Normal;
-                }
-            }
-        }
-    }
-    Ok(())
-}
-
-struct QueryResult {
-    columns: Vec<String>,
-    rows: Vec<Vec<Value>>,
-    truncated: bool,
-}
-
-fn run_select(conn: &mut Connection, sql: &str) -> Result<QueryResult> {
-    conn.execute_batch("BEGIN TRANSACTION READ ONLY")
-        .context("begin read-only admin SQL transaction")?;
-    let result = run_select_in_transaction(conn, sql);
-    match result {
-        Ok(value) => {
-            conn.execute_batch("COMMIT")
-                .context("commit read-only admin SQL transaction")?;
-            Ok(value)
-        }
-        Err(err) => {
-            if let Err(rb_err) = conn.execute_batch("ROLLBACK") {
-                tracing::warn!(
-                    error = ?rb_err,
-                    "rolling back admin SQL read-only transaction failed; the \
-                     original query error (returned to the caller) is the \
-                     actionable one"
-                );
-            }
-            Err(err)
-        }
-    }
-}
-
-fn run_select_in_transaction(conn: &Connection, sql: &str) -> Result<QueryResult> {
-    let mut stmt = conn.prepare(sql).context("prepare SQL")?;
-    let mut rows_iter = stmt.query([]).context("execute SQL")?;
-    // duckdb-rs panics on Statement::column_names() if the statement has not
-    // executed yet - schema is only populated after `query()` runs. Pull it
-    // off the live `Rows` iterator instead.
-    let columns: Vec<String> = rows_iter
-        .as_ref()
-        .map(|s| s.column_names())
-        .unwrap_or_default();
-    let column_count = columns.len();
-    let mut rows: Vec<Vec<Value>> = Vec::new();
-    let mut truncated = false;
-    while let Some(row) = rows_iter.next().context("row iter")? {
-        if rows.len() == ADMIN_SQL_ROW_LIMIT {
-            truncated = true;
-            break;
-        }
-        let mut out = Vec::with_capacity(column_count);
-        for i in 0..column_count {
-            let v = row.get_ref(i).context("get col")?;
-            out.push(value_ref_to_json(v));
-        }
-        rows.push(out);
-    }
-    Ok(QueryResult {
-        columns,
-        rows,
-        truncated,
-    })
-}
-
-/// Coerce a DuckDB [`ValueRef`] into a JSON [`Value`] for the admin SQL API.
-///
-/// `String::from_utf8_lossy` is used for `Text`: non-UTF-8 bytes in a TEXT
-/// column are a misuse but not a reason to fail the request; the lossy
-/// replacement (U+FFFD) surfaces so the caller can see something is wrong.
-///
-/// `Decimal` is rendered via its Display impl. `Timestamp` is rendered as
-/// `<unit>:<raw>` (one of `s|ms|us|ns:<count-since-epoch>`) so it
-/// round-trips through JSON unambiguously without pulling chrono / time
-/// in as a dependency; consumers that want a human-readable ISO-8601
-/// can post-process the string. Other compound types (`List`, `Struct`,
-/// `Array`, `Map`, `Union`, `Enum`) are rare in this database's schema;
-/// they fall back to a best-effort Debug rendering tagged with the type
-/// name so the caller can see something printable and we can extend
-/// this match when we hit one.
-fn value_ref_to_json(v: ValueRef<'_>) -> Value {
-    use duckdb::types::TimeUnit;
-    match v {
-        ValueRef::Null => Value::Null,
-        ValueRef::Boolean(b) => Value::Bool(b),
-        ValueRef::TinyInt(i) => Value::from(i),
-        ValueRef::SmallInt(i) => Value::from(i),
-        ValueRef::Int(i) => Value::from(i),
-        ValueRef::BigInt(i) => Value::from(i),
-        ValueRef::HugeInt(i) => Value::String(i.to_string()),
-        ValueRef::UTinyInt(i) => Value::from(i),
-        ValueRef::USmallInt(i) => Value::from(i),
-        ValueRef::UInt(i) => Value::from(i),
-        ValueRef::UBigInt(i) => Value::String(i.to_string()),
-        ValueRef::Float(f) => f64::from(f).into(),
-        ValueRef::Double(f) => f.into(),
-        ValueRef::Decimal(d) => Value::String(d.to_string()),
-        ValueRef::Timestamp(unit, raw) => {
-            // DuckDB stores timestamps as an integer count since
-            // 1970-01-01 UTC at the named precision. Surface them as a
-            // stable structured string keyed by the unit ("s:1700000000",
-            // "ms:1700000000000", etc.) so a future consumer can parse
-            // unambiguously without us reaching for chrono / time as a
-            // dependency in this slice.
-            let unit_str = match unit {
-                TimeUnit::Second => "s",
-                TimeUnit::Millisecond => "ms",
-                TimeUnit::Microsecond => "us",
-                TimeUnit::Nanosecond => "ns",
-            };
-            Value::String(format!("{unit_str}:{raw}"))
-        }
-        ValueRef::Text(bytes) => Value::String(String::from_utf8_lossy(bytes).into_owned()),
-        ValueRef::Blob(_) => Value::String("<blob>".into()),
-        other => Value::String(format!("{other:?}")),
-    }
-}
-
-fn format_table(r: &QueryResult) -> String {
-    if r.columns.is_empty() {
-        return "(no columns)\n".into();
-    }
-    let row_strings: Vec<Vec<String>> = r
-        .rows
-        .iter()
-        .map(|row| row.iter().map(value_display).collect())
-        .collect();
-    let mut widths: Vec<usize> = r.columns.iter().map(|c| c.chars().count()).collect();
-    for row in &row_strings {
-        for (i, cell) in row.iter().enumerate() {
-            let w = cell.chars().count();
-            if w > widths[i] {
-                widths[i] = w;
-            }
-        }
-    }
-    let mut out = String::new();
-    write_separator(&mut out, &widths, '┌', '┬', '┐');
-    write_row(&mut out, &r.columns, &widths);
-    write_separator(&mut out, &widths, '├', '┼', '┤');
-    for row in &row_strings {
-        write_row(&mut out, row, &widths);
-    }
-    write_separator(&mut out, &widths, '└', '┴', '┘');
-    // writeln! into a String only errors if the underlying Write impl
-    // returns one - fmt::Write for String is infallible - so the
-    // Result is discarded by design.
-    let _ = writeln!(
-        out,
-        "({} row{}{})",
-        r.rows.len(),
-        if r.rows.len() == 1 { "" } else { "s" },
-        if r.truncated { "; truncated" } else { "" },
-    );
-    out
-}
-
-fn value_display(v: &Value) -> String {
-    match v {
-        Value::Null => "NULL".into(),
-        Value::String(s) => s.clone(),
-        Value::Number(n) => n.to_string(),
-        Value::Bool(b) => b.to_string(),
-        other => other.to_string(),
-    }
-}
-
-fn write_row<S: AsRef<str>>(out: &mut String, cells: &[S], widths: &[usize]) {
-    out.push('│');
-    for (i, cell) in cells.iter().enumerate() {
-        let s = cell.as_ref();
-        let pad = widths[i].saturating_sub(s.chars().count());
-        out.push(' ');
-        out.push_str(s);
-        for _ in 0..pad {
-            out.push(' ');
-        }
-        out.push(' ');
-        out.push('│');
-    }
-    out.push('\n');
-}
-
-fn write_separator(out: &mut String, widths: &[usize], left: char, mid: char, right: char) {
-    out.push(left);
-    for (i, w) in widths.iter().enumerate() {
-        if i > 0 {
-            out.push(mid);
-        }
-        for _ in 0..(*w + 2) {
-            out.push('─');
-        }
-    }
-    out.push(right);
-    out.push('\n');
-}
diff --git a/benchmarks-website/server/src/api/charts.rs b/benchmarks-website/server/src/api/charts.rs
deleted file mode 100644
index 47e99c52058..00000000000
--- a/benchmarks-website/server/src/api/charts.rs
+++ /dev/null
@@ -1,642 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Per-chart payload assembly + the shared `SeriesAccumulator` glue.
-//!
-//! `chart_payload` dispatches on [`ChartKey`] to one of five
-//! `collect_*_chart` functions, each of which runs one SQL query against
-//! its fact table, threads the rows through a `SeriesAccumulator`, and
-//! returns a [`ChartResponse`].
-
-use std::collections::BTreeMap;
-use std::sync::Arc;
-
-use anyhow::Context as _;
-use anyhow::Result;
-use duckdb::Connection;
-use duckdb::ToSql;
-use duckdb::params_from_iter;
-
-use super::dto::ChartHistory;
-use super::dto::ChartResponse;
-use super::dto::CommitPoint;
-use super::dto::GroupChartsResponse;
-use super::dto::NamedChartResponse;
-use super::dto::SeriesTag;
-use super::dto::UnitKind;
-use super::groups::collect_groups;
-use super::window::CommitWindow;
-use crate::slug::ChartKey;
-use crate::slug::GroupKey;
-
-/// Build the JSON payload for one chart by key. This is the shared
-/// implementation behind `GET /api/chart/{slug}`, the inline `<script>` JSON
-/// rendered into the HTML pages, and `collect_group_charts`.
-///
-/// `window` caps the number of recent commits returned. `y` / `mode` are not
-/// inputs here — they're rendering hints applied client-side, so the SQL is
-/// unaffected and the cached payload is identical across hint values.
-pub(crate) fn chart_payload(
-    conn: &Connection,
-    key: &ChartKey,
-    window: &CommitWindow,
-) -> Result<Option<ChartResponse>> {
-    (crate::family::family_for_chart_key(key).collect_chart_for_key)(conn, key, window)
-}
-
-/// Collect every chart inside one group. Returns `None` if the group has no
-/// data at all (callers should render a 404).
-///
-/// TODO(#7812): this re-runs the entire [`collect_groups`] discovery pass
-/// per call before fetching each chart, so the landing page is
-/// O(groups * charts_per_group) DB queries plus the discovery scan. Fine
-/// for the current dataset; tracked for the refactor that collapses it
-/// into a single query.
-pub(crate) fn collect_group_charts(
-    conn: &Connection,
-    key: &GroupKey,
-    window: &CommitWindow,
-) -> Result<Option<GroupChartsResponse>> {
-    let groups = collect_groups(conn)?;
-    let group = groups.into_iter().find(|g| g.slug == key.to_slug());
-    let Some(group) = group else {
-        return Ok(None);
-    };
-    let mut charts = Vec::with_capacity(group.charts.len());
-    for link in group.charts {
-        let chart_key = ChartKey::from_slug(&link.slug)
-            .with_context(|| format!("invalid chart slug in group: {}", link.slug))?;
-        let Some(chart) = chart_payload(conn, &chart_key, window)? else {
-            continue;
-        };
-        charts.push(NamedChartResponse {
-            name: link.name,
-            slug: link.slug,
-            chart: Arc::new(chart),
-        });
-    }
-    if charts.is_empty() {
-        return Ok(None);
-    }
-    Ok(Some(GroupChartsResponse {
-        name: group.name,
-        summary: group.summary,
-        description: group.description,
-        charts,
-    }))
-}
-
-/// Time series rows are gathered keyed by `(commit_sha, series_key)` and then
-/// reshaped into the `commits[] / series{}` response shape.
-///
-/// **The accumulator is seeded with the canonical commits-in-window list
-/// before any fact rows are recorded.** That list is the chart's x-axis: it
-/// includes every commit in the requested [`CommitWindow`] whose timestamp
-/// is at or after the earliest commit that has a row in the fact table for
-/// this chart. Commits with zero rows in the fact table still appear in
-/// `commits[]`; their per-series slot stays `None` and renders as a visible
-/// gap in the line. Without seeding, commits absent from the fact table
-/// would be silently dropped from the chart's x-axis, making partial-coverage
-/// runs (a benchmark crashed; a series only runs nightly) look like
-/// continuous lines when they should break.
-struct SeriesAccumulator {
-    commits: Vec<CommitPoint>,
-    commit_index: BTreeMap<String, usize>,
-    series: BTreeMap<String, Vec<Option<f64>>>,
-    tags: BTreeMap<String, SeriesTag>,
-}
-
-impl SeriesAccumulator {
-    fn new() -> Self {
-        Self {
-            commits: Vec::new(),
-            commit_index: BTreeMap::new(),
-            series: BTreeMap::new(),
-            tags: BTreeMap::new(),
-        }
-    }
-
-    /// Seed the chart's commit list, oldest-first by timestamp. Must be
-    /// called before [`Self::record`] / [`Self::tag`] so series allocations
-    /// are sized correctly and missing-value slots stay `None`.
-    fn seed_commits(&mut self, commits: Vec<CommitPoint>) {
-        self.commit_index.clear();
-        for (i, c) in commits.iter().enumerate() {
-            self.commit_index.insert(c.sha.clone(), i);
-        }
-        self.commits = commits;
-    }
-
-    /// Index of `sha` in the seeded commits list, or `None` if the sha
-    /// was not part of the window. Returning `None` rather than panicking
-    /// keeps `collect_*_chart` resilient to an unseeded sha showing up in
-    /// the fact table (e.g. a transient race in concurrent ingest); we
-    /// just drop the row.
-    fn commit_idx(&self, sha: &str) -> Option<usize> {
-        self.commit_index.get(sha).copied()
-    }
-
-    fn record(&mut self, series_key: &str, commit_idx: usize, value: f64) {
-        let total_commits = self.commits.len();
-        let entry = self
-            .series
-            .entry(series_key.to_string())
-            .or_insert_with(|| vec![None; total_commits]);
-        if entry.len() < total_commits {
-            entry.resize(total_commits, None);
-        }
-        entry[commit_idx] = Some(value);
-    }
-
-    /// Record an engine/format classification for a series. Repeat calls with
-    /// the same `series_key` are idempotent — every row of a given series
-    /// shares the same engine/format by construction of the SQL.
-    fn tag(&mut self, series_key: &str, engine: Option<&str>, format: Option<&str>) {
-        if engine.is_none() && format.is_none() {
-            return;
-        }
-        let entry = self.tags.entry(series_key.to_string()).or_default();
-        if let Some(e) = engine {
-            entry.engine = Some(e.to_string());
-        }
-        if let Some(f) = format {
-            entry.format = Some(f.to_string());
-        }
-    }
-
-    fn finish(
-        self,
-        display_name: String,
-        unit_kind: UnitKind,
-        history: ChartHistory,
-    ) -> ChartResponse {
-        let total = self.commits.len();
-        let mut series_map = serde_json::Map::new();
-        for (k, mut v) in self.series {
-            if v.len() < total {
-                v.resize(total, None);
-            }
-            series_map.insert(k, serde_json::to_value(v).expect("Vec<Option<f64>>"));
-        }
-        ChartResponse {
-            display_name,
-            unit_kind,
-            history,
-            commits: self.commits,
-            series: series_map,
-            series_meta: self.tags,
-        }
-    }
-}
-
-struct SeededCommits {
-    commits: Vec<CommitPoint>,
-    history: ChartHistory,
-}
-
-/// Resolve a chart's x-axis: every commit in the requested commit-window
-/// whose timestamp is at or after the earliest commit that has a row in the
-/// fact table for this chart. Returns the list oldest-first; an empty list
-/// means the fact table has no rows at all for this chart, and the caller
-/// should return `None` (404).
-///
-/// `earliest_subquery` is spliced into the outer query as
-/// `c.timestamp >= ({earliest_subquery})`, so it must SELECT a single
-/// `MIN(timestamp)` row scoped to this chart's fact-table predicates. Its
-/// bound parameters appear first in `subquery_binds`; the window's `LIMIT`
-/// placeholder is appended after.
-///
-/// The bounds matter: without the timestamp lower bound a chart's x-axis
-/// would include every commit ever, including pre-history before the
-/// benchmark even existed. Without the [`CommitWindow`] cap a chart with a
-/// long history would always render the entire timeline regardless of the
-/// caller's `?n=` request.
-fn seeded_commits_in_window(
-    conn: &Connection,
-    earliest_subquery: &str,
-    subquery_binds: Vec<Box<dyn ToSql>>,
-    window: &CommitWindow,
-) -> Result<SeededCommits> {
-    let window_filter = match window {
-        CommitWindow::All => "",
-        CommitWindow::Last(_) => "WHERE rn > total_commits - ?",
-    };
-    let sql = format!(
-        r#"
-        WITH eligible AS (
-            SELECT c.commit_sha,
-                   c.timestamp,
-                   COALESCE(c.message, '') AS message,
-                   c.url,
-                   row_number() OVER (ORDER BY c.timestamp ASC, c.commit_sha ASC) AS rn,
-                   count(*) OVER () AS total_commits
-              FROM commits c
-             WHERE c.timestamp >= ({earliest_subquery})
-        )
-        SELECT commit_sha,
-               CAST(timestamp AS VARCHAR),
-               message,
-               url,
-               total_commits
-          FROM eligible
-         {window_filter}
-         ORDER BY timestamp ASC, commit_sha ASC
-        "#,
-    );
-    let mut stmt = conn.prepare(&sql)?;
-    let mut binds = subquery_binds;
-    push_window_limit(&mut binds, window);
-    let rows = stmt.query_map(params_from_iter(binds.iter()), |row| {
-        Ok((
-            CommitPoint {
-                sha: row.get(0)?,
-                timestamp: row.get(1)?,
-                message: row.get(2)?,
-                url: row.get(3)?,
-            },
-            row.get::<_, i64>(4)?,
-        ))
-    })?;
-    let rows: Vec<(CommitPoint, i64)> = rows.collect::<Result<_, _>>()?;
-    let total_commits = rows
-        .first()
-        .map(|(_, total)| usize::try_from(*total))
-        .transpose()?
-        .unwrap_or_default();
-    let commits: Vec<CommitPoint> = rows.into_iter().map(|(commit, _)| commit).collect();
-    let loaded_commits = commits.len();
-    let start_index = total_commits.saturating_sub(loaded_commits);
-    Ok(SeededCommits {
-        commits,
-        history: ChartHistory {
-            total_commits,
-            start_index,
-            loaded_commits,
-            complete: loaded_commits == total_commits,
-        },
-    })
-}
-
-/// Append the commit-window `LIMIT` bind value to a parameter list, when the
-/// window is bounded. Pairs with [`CommitWindow::sql_filter`] which emits
-/// the matching `?` placeholder.
-fn push_window_limit(binds: &mut Vec<Box<dyn ToSql>>, window: &CommitWindow) {
-    if let Some(limit) = window.limit_param() {
-        binds.push(Box::new(limit));
-    }
-}
-
-pub(crate) fn collect_query_chart(
-    conn: &Connection,
-    dataset: &str,
-    dataset_variant: &Option<String>,
-    scale_factor: &Option<String>,
-    storage: &str,
-    query_idx: i32,
-    window: &CommitWindow,
-) -> Result<Option<ChartResponse>> {
-    // x-axis pre-pass. `IS NOT DISTINCT FROM` matches NULL == NULL so charts
-    // with a NULL `dataset_variant` or `scale_factor` still pin the right
-    // earliest-commit timestamp.
-    let seeded = seeded_commits_in_window(
-        conn,
-        "SELECT MIN(c2.timestamp) \
-           FROM query_measurements q2 \
-           JOIN commits c2 ON c2.commit_sha = q2.commit_sha \
-          WHERE q2.dataset = ? \
-            AND q2.dataset_variant IS NOT DISTINCT FROM ? \
-            AND q2.scale_factor    IS NOT DISTINCT FROM ? \
-            AND q2.storage = ? \
-            AND q2.query_idx = ?",
-        vec![
-            Box::new(dataset.to_string()),
-            Box::new(dataset_variant.clone()),
-            Box::new(scale_factor.clone()),
-            Box::new(storage.to_string()),
-            Box::new(query_idx),
-        ],
-        window,
-    )?;
-    if seeded.commits.is_empty() {
-        return Ok(None);
-    }
-    let history = seeded.history;
-    let mut acc = SeriesAccumulator::new();
-    acc.seed_commits(seeded.commits);
-
-    let sql = format!(
-        r#"
-        SELECT q.commit_sha,
-               q.engine, q.format, q.value_ns
-          FROM query_measurements q
-          JOIN commits c USING (commit_sha)
-         WHERE q.dataset = ?
-           AND q.dataset_variant IS NOT DISTINCT FROM ?
-           AND q.scale_factor    IS NOT DISTINCT FROM ?
-           AND q.storage = ?
-           AND q.query_idx = ?{filter}
-         ORDER BY c.timestamp, q.engine, q.format
-        "#,
-        filter = window.sql_filter(),
-    );
-    let mut stmt = conn.prepare(&sql)?;
-    let mut binds: Vec<Box<dyn ToSql>> = vec![
-        Box::new(dataset.to_string()),
-        Box::new(dataset_variant.clone()),
-        Box::new(scale_factor.clone()),
-        Box::new(storage.to_string()),
-        Box::new(query_idx),
-    ];
-    push_window_limit(&mut binds, window);
-    let rows = stmt.query_map(params_from_iter(binds.iter()), |row| {
-        Ok((
-            row.get::<_, String>(0)?,
-            row.get::<_, String>(1)?,
-            row.get::<_, String>(2)?,
-            row.get::<_, i64>(3)?,
-        ))
-    })?;
-    for row in rows {
-        let (sha, engine, format, value_ns) = row?;
-        let Some(idx) = acc.commit_idx(&sha) else {
-            continue;
-        };
-        let series_key = format!("{engine}:{format}");
-        acc.record(&series_key, idx, value_ns as f64);
-        acc.tag(&series_key, Some(&engine), Some(&format));
-    }
-    let mut name = dataset.to_string();
-    if let Some(v) = dataset_variant {
-        name.push('/');
-        name.push_str(v);
-    }
-    if let Some(sf) = scale_factor {
-        name.push_str(" sf=");
-        name.push_str(sf);
-    }
-    name.push_str(&format!(" Q{query_idx} [{storage}]"));
-    Ok(Some(acc.finish(name, UnitKind::TimeNs, history)))
-}
-
-pub(crate) fn collect_compression_time_chart(
-    conn: &Connection,
-    dataset: &str,
-    dataset_variant: &Option<String>,
-    window: &CommitWindow,
-) -> Result<Option<ChartResponse>> {
-    let seeded = seeded_commits_in_window(
-        conn,
-        "SELECT MIN(c2.timestamp) \
-           FROM compression_times t2 \
-           JOIN commits c2 ON c2.commit_sha = t2.commit_sha \
-          WHERE t2.dataset = ? \
-            AND t2.dataset_variant IS NOT DISTINCT FROM ?",
-        vec![
-            Box::new(dataset.to_string()),
-            Box::new(dataset_variant.clone()),
-        ],
-        window,
-    )?;
-    if seeded.commits.is_empty() {
-        return Ok(None);
-    }
-    let history = seeded.history;
-    let mut acc = SeriesAccumulator::new();
-    acc.seed_commits(seeded.commits);
-
-    let sql = format!(
-        r#"
-        SELECT t.commit_sha,
-               t.format, t.op, t.value_ns
-          FROM compression_times t
-          JOIN commits c USING (commit_sha)
-         WHERE t.dataset = ?
-           AND t.dataset_variant IS NOT DISTINCT FROM ?{filter}
-         ORDER BY c.timestamp, t.format, t.op
-        "#,
-        filter = window.sql_filter(),
-    );
-    let mut stmt = conn.prepare(&sql)?;
-    let mut binds: Vec<Box<dyn ToSql>> = vec![
-        Box::new(dataset.to_string()),
-        Box::new(dataset_variant.clone()),
-    ];
-    push_window_limit(&mut binds, window);
-    let rows = stmt.query_map(params_from_iter(binds.iter()), |row| {
-        Ok((
-            row.get::<_, String>(0)?,
-            row.get::<_, String>(1)?,
-            row.get::<_, String>(2)?,
-            row.get::<_, i64>(3)?,
-        ))
-    })?;
-    for row in rows {
-        let (sha, format, op, value_ns) = row?;
-        let Some(idx) = acc.commit_idx(&sha) else {
-            continue;
-        };
-        let series_key = format!("{format}:{op}");
-        acc.record(&series_key, idx, value_ns as f64);
-        acc.tag(&series_key, None, Some(&format));
-    }
-    let mut name = dataset.to_string();
-    if let Some(v) = dataset_variant {
-        name.push('/');
-        name.push_str(v);
-    }
-    Ok(Some(acc.finish(name, UnitKind::TimeNs, history)))
-}
-
-pub(crate) fn collect_compression_size_chart(
-    conn: &Connection,
-    dataset: &str,
-    dataset_variant: &Option<String>,
-    window: &CommitWindow,
-) -> Result<Option<ChartResponse>> {
-    let seeded = seeded_commits_in_window(
-        conn,
-        "SELECT MIN(c2.timestamp) \
-           FROM compression_sizes s2 \
-           JOIN commits c2 ON c2.commit_sha = s2.commit_sha \
-          WHERE s2.dataset = ? \
-            AND s2.dataset_variant IS NOT DISTINCT FROM ?",
-        vec![
-            Box::new(dataset.to_string()),
-            Box::new(dataset_variant.clone()),
-        ],
-        window,
-    )?;
-    if seeded.commits.is_empty() {
-        return Ok(None);
-    }
-    let history = seeded.history;
-    let mut acc = SeriesAccumulator::new();
-    acc.seed_commits(seeded.commits);
-
-    let sql = format!(
-        r#"
-        SELECT s.commit_sha,
-               s.format, s.value_bytes
-          FROM compression_sizes s
-          JOIN commits c USING (commit_sha)
-         WHERE s.dataset = ?
-           AND s.dataset_variant IS NOT DISTINCT FROM ?{filter}
-         ORDER BY c.timestamp, s.format
-        "#,
-        filter = window.sql_filter(),
-    );
-    let mut stmt = conn.prepare(&sql)?;
-    let mut binds: Vec<Box<dyn ToSql>> = vec![
-        Box::new(dataset.to_string()),
-        Box::new(dataset_variant.clone()),
-    ];
-    push_window_limit(&mut binds, window);
-    let rows = stmt.query_map(params_from_iter(binds.iter()), |row| {
-        Ok((
-            row.get::<_, String>(0)?,
-            row.get::<_, String>(1)?,
-            row.get::<_, i64>(2)?,
-        ))
-    })?;
-    for row in rows {
-        let (sha, format, value_bytes) = row?;
-        let Some(idx) = acc.commit_idx(&sha) else {
-            continue;
-        };
-        acc.record(&format, idx, value_bytes as f64);
-        acc.tag(&format, None, Some(&format));
-    }
-    let mut name = dataset.to_string();
-    if let Some(v) = dataset_variant {
-        name.push('/');
-        name.push_str(v);
-    }
-    Ok(Some(acc.finish(name, UnitKind::Bytes, history)))
-}
-
-pub(crate) fn collect_random_access_chart(
-    conn: &Connection,
-    dataset: &str,
-    window: &CommitWindow,
-) -> Result<Option<ChartResponse>> {
-    let seeded = seeded_commits_in_window(
-        conn,
-        "SELECT MIN(c2.timestamp) \
-           FROM random_access_times r2 \
-           JOIN commits c2 ON c2.commit_sha = r2.commit_sha \
-          WHERE r2.dataset = ?",
-        vec![Box::new(dataset.to_string())],
-        window,
-    )?;
-    if seeded.commits.is_empty() {
-        return Ok(None);
-    }
-    let history = seeded.history;
-    let mut acc = SeriesAccumulator::new();
-    acc.seed_commits(seeded.commits);
-
-    let sql = format!(
-        r#"
-        SELECT r.commit_sha,
-               r.format, r.value_ns
-          FROM random_access_times r
-          JOIN commits c USING (commit_sha)
-         WHERE r.dataset = ?{filter}
-         ORDER BY c.timestamp, r.format
-        "#,
-        filter = window.sql_filter(),
-    );
-    let mut stmt = conn.prepare(&sql)?;
-    let mut binds: Vec<Box<dyn ToSql>> = vec![Box::new(dataset.to_string())];
-    push_window_limit(&mut binds, window);
-    let rows = stmt.query_map(params_from_iter(binds.iter()), |row| {
-        Ok((
-            row.get::<_, String>(0)?,
-            row.get::<_, String>(1)?,
-            row.get::<_, i64>(2)?,
-        ))
-    })?;
-    for row in rows {
-        let (sha, format, value_ns) = row?;
-        let Some(idx) = acc.commit_idx(&sha) else {
-            continue;
-        };
-        acc.record(&format, idx, value_ns as f64);
-        acc.tag(&format, None, Some(&format));
-    }
-    Ok(Some(acc.finish(
-        dataset.to_string(),
-        UnitKind::TimeNs,
-        history,
-    )))
-}
-
-pub(crate) fn collect_vector_search_chart(
-    conn: &Connection,
-    dataset: &str,
-    layout: &str,
-    threshold: f64,
-    window: &CommitWindow,
-) -> Result<Option<ChartResponse>> {
-    let seeded = seeded_commits_in_window(
-        conn,
-        "SELECT MIN(c2.timestamp) \
-           FROM vector_search_runs v2 \
-           JOIN commits c2 ON c2.commit_sha = v2.commit_sha \
-          WHERE v2.dataset = ? \
-            AND v2.layout = ? \
-            AND v2.threshold = ?",
-        vec![
-            Box::new(dataset.to_string()),
-            Box::new(layout.to_string()),
-            Box::new(threshold),
-        ],
-        window,
-    )?;
-    if seeded.commits.is_empty() {
-        return Ok(None);
-    }
-    let history = seeded.history;
-    let mut acc = SeriesAccumulator::new();
-    acc.seed_commits(seeded.commits);
-
-    let sql = format!(
-        r#"
-        SELECT v.commit_sha,
-               v.flavor, v.value_ns
-          FROM vector_search_runs v
-          JOIN commits c USING (commit_sha)
-         WHERE v.dataset = ?
-           AND v.layout = ?
-           AND v.threshold = ?{filter}
-         ORDER BY c.timestamp, v.flavor
-        "#,
-        filter = window.sql_filter(),
-    );
-    let mut stmt = conn.prepare(&sql)?;
-    let mut binds: Vec<Box<dyn ToSql>> = vec![
-        Box::new(dataset.to_string()),
-        Box::new(layout.to_string()),
-        Box::new(threshold),
-    ];
-    push_window_limit(&mut binds, window);
-    let rows = stmt.query_map(params_from_iter(binds.iter()), |row| {
-        Ok((
-            row.get::<_, String>(0)?,
-            row.get::<_, String>(1)?,
-            row.get::<_, i64>(2)?,
-        ))
-    })?;
-    for row in rows {
-        let (sha, flavor, value_ns) = row?;
-        let Some(idx) = acc.commit_idx(&sha) else {
-            continue;
-        };
-        acc.record(&flavor, idx, value_ns as f64);
-    }
-    Ok(Some(acc.finish(
-        format!("{dataset} / {layout} (threshold={threshold})"),
-        UnitKind::TimeNs,
-        history,
-    )))
-}
diff --git a/benchmarks-website/server/src/api/descriptions.rs b/benchmarks-website/server/src/api/descriptions.rs
deleted file mode 100644
index 9a867f08fbd..00000000000
--- a/benchmarks-website/server/src/api/descriptions.rs
+++ /dev/null
@@ -1,214 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Editorial group descriptions, ported from v2.
-//!
-//! These strings are the source of truth for the hover tooltip rendered on
-//! every `<details>` group title on the landing page and on the
-//! `/group/{slug}` permalink. They are deliberately editorial and
-//! hand-maintained — derived from the group *name*, not from the database —
-//! so that adding a new group's blurb is a one-line edit here rather than a
-//! schema or ingest change.
-//!
-//! Source of truth in v2 (kept verbatim where applicable):
-//! - `benchmarks-website/src/utils.js` — `getBenchmarkDescription`
-//! - `benchmarks-website/src/config.js` — `BENCHMARK_DESCRIPTIONS`,
-//!   `QUERY_SUITES.description`
-//!
-//! TPC-H / TPC-DS fan out by storage and scale factor; the description is
-//! synthesised from the parsed name so we don't have to hand-maintain one
-//! entry per `(storage, sf)` pair.
-
-/// Look up a short editorial description for a group display name. Returns
-/// `None` when the group has no canonical description (e.g. vector-search
-/// groups) — callers render the title without a tooltip in that case.
-pub fn group_description(name: &str) -> Option<String> {
-    if let Some(d) = tpc_description(name) {
-        return Some(d);
-    }
-    static_description(name).map(str::to_string)
-}
-
-/// Hard-coded, name-keyed descriptions for the non-fan-out groups. These
-/// match v2 verbatim where v2 had a description; new strings here should
-/// match the wording style v2 set.
-fn static_description(name: &str) -> Option<&'static str> {
-    match name {
-        "Random Access" => {
-            Some("Tests performance of selecting arbitrary row indices from a file on NVMe storage")
-        }
-        "Compression" => Some(
-            "Measures encoding and decoding throughput (MB/s) for Vortex files and Parquet \
-             files (with zstd page compression)",
-        ),
-        "Compression Size" => Some(
-            "Compares compressed file sizes and compression ratios across different encoding \
-             strategies",
-        ),
-        "Clickbench" => Some(
-            "ClickHouse's analytical benchmark suite testing real-world query patterns on web \
-             analytics data",
-        ),
-        "Statistical and Population Genetics" => {
-            Some("A suite of Statistical and Population genetics queries using the gnomAD dataset")
-        }
-        "PolarSignals Profiling" => Some(
-            "Profiling data benchmark modeled on PolarSignals/Parca, exercising scan-layer \
-             performance with projection and filter pushdown on deeply nested schemas",
-        ),
-        _ => None,
-    }
-}
-
-/// Derive a description for `TPC-H (NVMe|S3) (SF=N)` and `TPC-DS (NVMe) (SF=N)`
-/// group names. The shape is fixed because [`crate::api::groups::group_name_query`]
-/// emits exactly this format for tpch/tpcds. Returns `None` for any name that
-/// does not start with `TPC-H ` or `TPC-DS `.
-fn tpc_description(name: &str) -> Option<String> {
-    let parts = if let Some(rest) = name.strip_prefix("TPC-H ") {
-        Some(("TPC-H", rest))
-    } else {
-        name.strip_prefix("TPC-DS ").map(|rest| ("TPC-DS", rest))
-    };
-    let (suite, rest) = parts?;
-    let storage = if rest.starts_with("(NVMe)") {
-        "nvme"
-    } else if rest.starts_with("(S3)") {
-        "s3"
-    } else {
-        return None;
-    };
-    let sf = parse_sf(rest)?;
-    Some(format_tpc(suite, storage, &sf))
-}
-
-/// Pull `SF=N` (digits only) out of strings like `(NVMe) (SF=10)`. Returns
-/// `None` if no `SF=` substring or the digits don't parse.
-fn parse_sf(s: &str) -> Option<String> {
-    let after = s.split_once("SF=")?.1;
-    let digits: String = after.chars().take_while(char::is_ascii_digit).collect();
-    if digits.is_empty() {
-        None
-    } else {
-        Some(digits)
-    }
-}
-
-/// Render the v2-compatible TPC blurb. Storage label comes from the parsed
-/// group name; scale-bytes annotation only renders for TPC-H (TPC-DS in v2
-/// did not annotate scale bytes).
-fn format_tpc(suite: &str, storage: &str, sf: &str) -> String {
-    let storage_phrase = match storage {
-        "nvme" => "on local NVMe storage",
-        "s3" => "against S3 storage",
-        _ => "on local NVMe storage",
-    };
-    let bytes = match sf {
-        "1" => Some("1GB"),
-        "10" => Some("10GB"),
-        "100" => Some("100GB"),
-        "1000" => Some("1TB"),
-        _ => None,
-    };
-    match (suite, bytes) {
-        ("TPC-H", Some(b)) => {
-            format!("TPC-H benchmark queries {storage_phrase} at SF={sf} (~{b} of data)",)
-        }
-        ("TPC-H", None) => format!("TPC-H benchmark queries {storage_phrase} at SF={sf}"),
-        ("TPC-DS", _) => format!("TPC-DS benchmark queries {storage_phrase} at SF={sf}"),
-        _ => format!("{suite} benchmark queries {storage_phrase} at SF={sf}"),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn static_descriptions_match_v2() {
-        assert_eq!(
-            group_description("Random Access").as_deref(),
-            Some(
-                "Tests performance of selecting arbitrary row indices from a file on NVMe storage"
-            ),
-        );
-        assert_eq!(
-            group_description("Compression").as_deref(),
-            Some(
-                "Measures encoding and decoding throughput (MB/s) for Vortex files and Parquet \
-                 files (with zstd page compression)",
-            ),
-        );
-        assert_eq!(
-            group_description("Compression Size").as_deref(),
-            Some(
-                "Compares compressed file sizes and compression ratios across different encoding \
-                 strategies",
-            ),
-        );
-        assert_eq!(
-            group_description("Clickbench").as_deref(),
-            Some(
-                "ClickHouse's analytical benchmark suite testing real-world query patterns on \
-                 web analytics data",
-            ),
-        );
-        assert_eq!(
-            group_description("Statistical and Population Genetics").as_deref(),
-            Some("A suite of Statistical and Population genetics queries using the gnomAD dataset",),
-        );
-        assert_eq!(
-            group_description("PolarSignals Profiling").as_deref(),
-            Some(
-                "Profiling data benchmark modeled on PolarSignals/Parca, exercising scan-layer \
-                 performance with projection and filter pushdown on deeply nested schemas",
-            ),
-        );
-    }
-
-    #[test]
-    fn tpch_descriptions_carry_scale_bytes() {
-        assert_eq!(
-            group_description("TPC-H (NVMe) (SF=1)").as_deref(),
-            Some("TPC-H benchmark queries on local NVMe storage at SF=1 (~1GB of data)"),
-        );
-        assert_eq!(
-            group_description("TPC-H (S3) (SF=10)").as_deref(),
-            Some("TPC-H benchmark queries against S3 storage at SF=10 (~10GB of data)"),
-        );
-        assert_eq!(
-            group_description("TPC-H (NVMe) (SF=100)").as_deref(),
-            Some("TPC-H benchmark queries on local NVMe storage at SF=100 (~100GB of data)"),
-        );
-        assert_eq!(
-            group_description("TPC-H (S3) (SF=1000)").as_deref(),
-            Some("TPC-H benchmark queries against S3 storage at SF=1000 (~1TB of data)"),
-        );
-    }
-
-    #[test]
-    fn tpcds_descriptions_omit_scale_bytes() {
-        assert_eq!(
-            group_description("TPC-DS (NVMe) (SF=1)").as_deref(),
-            Some("TPC-DS benchmark queries on local NVMe storage at SF=1"),
-        );
-        assert_eq!(
-            group_description("TPC-DS (NVMe) (SF=10)").as_deref(),
-            Some("TPC-DS benchmark queries on local NVMe storage at SF=10"),
-        );
-    }
-
-    #[test]
-    fn unknown_groups_have_no_description() {
-        assert_eq!(group_description("cohere-large-10m / partitioned"), None);
-        assert_eq!(group_description("Made-up benchmark"), None);
-    }
-
-    #[test]
-    fn malformed_tpc_names_fall_through() {
-        // No `(NVMe)` / `(S3)` prefix → not matched.
-        assert_eq!(group_description("TPC-H something else"), None);
-        // SF= without digits → not matched.
-        assert_eq!(group_description("TPC-H (NVMe) (SF=)"), None);
-    }
-}
diff --git a/benchmarks-website/server/src/api/dto.rs b/benchmarks-website/server/src/api/dto.rs
deleted file mode 100644
index b3dc90622ec..00000000000
--- a/benchmarks-website/server/src/api/dto.rs
+++ /dev/null
@@ -1,382 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Wire-shape data transfer objects for the read API.
-//!
-//! These structs are the JSON the server emits on `/api/groups`,
-//! `/api/group/{slug}`, `/api/chart/{slug}`, and `/health`. Renaming or
-//! reordering fields is a wire-compat break - coordinate with
-//! `chart-init.js` (and the emitter / migrator if the change is on the
-//! ingest side, see [`crate::records`]).
-
-use std::collections::BTreeMap;
-use std::sync::Arc;
-
-use serde::Serialize;
-use serde_json::Value as JsonValue;
-
-/// Default cap on the number of commits returned per chart when no `?n=` is
-/// supplied. The HTML routes override this with their own per-page defaults
-/// (see [`crate::html`]).
-pub const DEFAULT_COMMIT_WINDOW: u32 = 100;
-
-/// Canonical group ordering, ported from the v2 site's hard-coded list at
-/// `origin/ct/vfvb:benchmarks-website/index.html`. Group names not in this
-/// list sort after every listed name in alphabetical order. The order is
-/// significant for the landing page render - every group is collapsed by
-/// default, and the disclosure list is rendered in this sequence. Chart
-/// payloads are NOT inlined into the landing HTML; every group hydrates
-/// from versioned shard artifacts under
-/// `/api/artifacts/{generation}/groups/{slug}/shards/{i}` on first
-/// intent/open, served from the precomputed read store (see
-/// `server/ARCHITECTURE.md` → "Hot Read Path").
-pub const GROUP_ORDER: &[&str] = &[
-    "Random Access",
-    "Compression",
-    "Compression Size",
-    "Clickbench",
-    "TPC-H (NVMe) (SF=1)",
-    "TPC-H (S3) (SF=1)",
-    "TPC-H (NVMe) (SF=10)",
-    "TPC-H (S3) (SF=10)",
-    "TPC-H (NVMe) (SF=100)",
-    "TPC-H (S3) (SF=100)",
-    "TPC-H (NVMe) (SF=1000)",
-    "TPC-H (S3) (SF=1000)",
-    "TPC-DS (NVMe) (SF=1)",
-    "TPC-DS (NVMe) (SF=10)",
-];
-
-/// Sort key for a group name against [`GROUP_ORDER`]. Names in the list sort
-/// by position (0..GROUP_ORDER.len()); names not in the list sort after, by
-/// the same primary index plus an alphabetical tiebreaker.
-pub fn group_sort_key(name: &str) -> (usize, &str) {
-    let pos = GROUP_ORDER
-        .iter()
-        .position(|&n| n == name)
-        .unwrap_or(GROUP_ORDER.len());
-    (pos, name)
-}
-
-/// Body of `GET /api/groups`: every group with its chart links and summary.
-///
-/// The inner [`Vec`] is held in an [`Arc`] so [`crate::query_cache::QueryCache`]
-/// can serve the same allocation to every concurrent reader without cloning.
-/// `Arc<T>` serialises through to `T`, so the wire shape is unchanged.
-#[derive(Debug, Serialize)]
-pub struct GroupsResponse {
-    /// Every group surfaced by the discovery passes, in canonical order.
-    pub groups: Arc<Vec<Group>>,
-}
-
-/// One group: a display name, a slug for the group permalink, and the chart
-/// links inside it. Optionally carries a v2-compatible rollup summary and a
-/// short editorial description (rendered as a hover tooltip on the
-/// disclosure title).
-#[derive(Debug, Clone, Serialize)]
-pub struct Group {
-    /// Human-readable group label rendered in the disclosure header.
-    pub name: String,
-    /// Slug for `/group/{slug}`. Round-trips through [`crate::slug::GroupKey`].
-    pub slug: String,
-    /// Chart links inside the group, one per chart card.
-    pub charts: Vec<ChartLink>,
-    /// Optional v2-compatible rollup computed from the fact tables.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub summary: Option<Summary>,
-    /// Short editorial description ported from v2's `BENCHMARK_DESCRIPTIONS` +
-    /// `getBenchmarkDescription`. Rendered as a hover tooltip on the disclosure title; absent when
-    /// no description exists for this group name (e.g. vector-search groups).
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub description: Option<String>,
-}
-
-/// All charts in one group, returned by `GET /api/group/{slug}`.
-#[derive(Debug, Clone, Serialize)]
-pub struct GroupChartsResponse {
-    /// Group display name, matching the `name` field on [`Group`].
-    pub name: String,
-    /// Optional v2-compatible rollup computed from the fact tables.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub summary: Option<Summary>,
-    /// Optional editorial description, mirroring [`Group::description`].
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub description: Option<String>,
-    /// Every chart inside the group, with full payload inlined.
-    pub charts: Vec<NamedChartResponse>,
-}
-
-/// Server-computed group summary, matching the v2 metadata contract.
-#[derive(Debug, Clone, Serialize)]
-#[serde(tag = "type")]
-pub enum Summary {
-    /// Random-access format ranking for the latest populated random-access chart.
-    #[serde(rename = "randomAccess")]
-    RandomAccess {
-        /// Header text for the summary card.
-        title: &'static str,
-        /// One row per format, sorted fastest-first.
-        rankings: Vec<RandomAccessRanking>,
-        /// Footer explainer rendered below the rankings.
-        explanation: &'static str,
-    },
-    /// Compression/decompression speedup of Vortex over Parquet.
-    #[serde(rename = "compression")]
-    Compression {
-        /// Header text for the summary card.
-        title: &'static str,
-        /// Geomean of `parquet/vortex` encode ratios; absent if no encode rows exist.
-        #[serde(rename = "compressRatio", skip_serializing_if = "Option::is_none")]
-        compress_ratio: Option<f64>,
-        /// Geomean of `parquet/vortex` decode ratios; absent if no decode rows exist.
-        #[serde(rename = "decompressRatio", skip_serializing_if = "Option::is_none")]
-        decompress_ratio: Option<f64>,
-        /// How many distinct datasets fed the geomean.
-        #[serde(rename = "datasetCount")]
-        dataset_count: usize,
-        /// Footer explainer rendered below the values.
-        explanation: &'static str,
-    },
-    /// Vortex-to-Parquet compressed size ratio distribution.
-    #[serde(rename = "compressionSize")]
-    CompressionSize {
-        /// Header text for the summary card.
-        title: &'static str,
-        /// Smallest observed `vortex/parquet` ratio across datasets.
-        #[serde(rename = "minRatio")]
-        min_ratio: f64,
-        /// Geomean across datasets.
-        #[serde(rename = "meanRatio")]
-        mean_ratio: f64,
-        /// Largest observed ratio.
-        #[serde(rename = "maxRatio")]
-        max_ratio: f64,
-        /// How many datasets contributed.
-        #[serde(rename = "datasetCount")]
-        dataset_count: usize,
-        /// Footer explainer rendered below the values.
-        explanation: &'static str,
-    },
-    /// Query-suite ranking by geomean ratio to the fastest engine per query.
-    #[serde(rename = "queryBenchmark")]
-    QueryBenchmark {
-        /// Header text for the summary card.
-        title: &'static str,
-        /// One row per `engine:format`, sorted lowest-score-first.
-        rankings: Vec<QueryRanking>,
-        /// Footer explainer rendered below the rankings.
-        explanation: &'static str,
-    },
-}
-
-/// One random-access summary row.
-#[derive(Debug, Clone, Serialize)]
-pub struct RandomAccessRanking {
-    /// Series name, normally the physical format.
-    pub name: String,
-    /// Latest measured time in nanoseconds.
-    pub time: f64,
-    /// Ratio to the fastest series in the same chart.
-    pub ratio: f64,
-}
-
-/// One query benchmark summary row.
-#[derive(Debug, Clone, Serialize)]
-pub struct QueryRanking {
-    /// Series name, normally `engine:format`.
-    pub name: String,
-    /// Geomean ratio to the fastest observed value per query.
-    pub score: f64,
-    /// Sum of latest runtimes for the queries this series has.
-    #[serde(rename = "totalRuntime")]
-    pub total_runtime: f64,
-}
-
-/// A single chart inside a [`GroupChartsResponse`]. `name` is the chart's
-/// short label inside the group (e.g. `Q1`); `slug` round-trips through
-/// `/api/chart/{slug}`.
-///
-/// `chart` is held in an [`Arc`] so the cache and the landing-page builder
-/// share the same allocation; `Arc<T>` serialises as `T`, so the wire shape
-/// is identical to a plain `ChartResponse`.
-#[derive(Debug, Clone, Serialize)]
-pub struct NamedChartResponse {
-    /// Chart label rendered in the chart-card title (e.g. `Q1`).
-    pub name: String,
-    /// Slug for `/chart/{slug}`. Round-trips through [`crate::slug::ChartKey`].
-    pub slug: String,
-    /// Inlined chart payload - same shape as `/api/chart/{slug}`.
-    #[serde(flatten)]
-    pub chart: Arc<ChartResponse>,
-}
-
-/// One chart's short label inside a group (e.g. `Q1`) plus the slug that
-/// resolves to its `/api/chart/{slug}` payload.
-#[derive(Debug, Clone, Serialize)]
-pub struct ChartLink {
-    /// Chart label rendered in the chart-card title (e.g. `Q1`).
-    pub name: String,
-    /// Slug for `/chart/{slug}`. Round-trips through [`crate::slug::ChartKey`].
-    pub slug: String,
-}
-
-/// Body of `GET /api/chart/{slug}`: every commit with data, every series'
-/// values aligned to those commits, and per-series engine/format tags.
-#[derive(Debug, Clone, Serialize)]
-pub struct ChartResponse {
-    /// Human-readable title for the chart (e.g. `tpch sf=1 Q1 [nvme]`).
-    pub display_name: String,
-    /// Structured taxonomy describing what the y-axis values *are* (time in
-    /// nanoseconds, bytes, etc.). The client uses this together with the
-    /// magnitude of the loaded values to pick a display unit (e.g. `ms` for
-    /// time values around 1e6 ns) so the rendered axis stays readable. The
-    /// taxonomy is small on purpose - see [`UnitKind`].
-    pub unit_kind: UnitKind,
-    /// Full-history placement of this payload's bounded `commits` window.
-    pub history: ChartHistory,
-    /// Every loaded commit in this payload, oldest first.
-    pub commits: Vec<CommitPoint>,
-    /// Per-series value arrays, indexed in lockstep with `commits`.
-    pub series: serde_json::Map<String, JsonValue>,
-    /// Per-series engine/format classification, used by the global filter
-    /// bar to hide/show whole engines or formats across every chart at once.
-    /// Keyed by series name; values are populated only for series whose name
-    /// encodes an engine and/or format. Series without a classification (e.g.
-    /// vector-search flavors) are simply absent from this map.
-    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
-    pub series_meta: BTreeMap<String, SeriesTag>,
-}
-
-/// Placement metadata for a possibly bounded chart payload.
-#[derive(Debug, Clone, Serialize)]
-pub struct ChartHistory {
-    /// Number of commits in this chart's full x-axis after the benchmark's
-    /// first data point.
-    pub total_commits: usize,
-    /// Index in the full x-axis where `commits[0]` belongs.
-    pub start_index: usize,
-    /// Number of commits loaded into this payload.
-    pub loaded_commits: usize,
-    /// True when this payload covers the full x-axis.
-    pub complete: bool,
-}
-
-/// Structured y-axis unit taxonomy carried on every [`ChartResponse`]. The
-/// client uses this - together with the magnitude of the values currently in
-/// view - to pick a display unit (e.g. `ms` for `time_ns` values around
-/// 1e6) so the rendered axis stays readable. Stored values on the wire are
-/// always in the kind's *base* unit:
-///
-/// | Variant            | Base unit on the wire |
-/// |--------------------|-----------------------|
-/// | [`Self::TimeNs`]   | nanoseconds           |
-/// | [`Self::Bytes`]    | bytes                 |
-/// | [`Self::Ratio`]    | dimensionless ratio   |
-/// | [`Self::Count`]    | dimensionless count   |
-/// | [`Self::ThroughputMbS`] | megabytes per second |
-///
-/// Adding a variant is a wire-compat change - coordinate with the emitter,
-/// migrator, and the client unit picker in `chart-init.js`.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
-#[serde(rename_all = "snake_case")]
-pub enum UnitKind {
-    /// Times stored as integer nanoseconds. Client picks from `ns | µs | ms | s`.
-    TimeNs,
-    /// Sizes stored as integer bytes. Client picks from `B | KiB | MiB | GiB | TiB`
-    /// (binary multiples) unless a series's `series_meta` overrides it.
-    Bytes,
-    /// Dimensionless ratio (e.g. compression-ratio derived charts). The
-    /// client renders the values verbatim and uses no unit suffix.
-    Ratio,
-    /// Dimensionless integer count. Same client behaviour as [`Self::Ratio`].
-    Count,
-    /// Throughput in megabytes per second. The client renders the values
-    /// verbatim with an `MB/s` suffix; no auto-scaling is applied today.
-    #[serde(rename = "throughput_mb_s")]
-    ThroughputMbS,
-}
-
-impl UnitKind {
-    /// Short label used for the chart-page meta caption (`"unit: ns"`). The
-    /// labels match the kind's base unit on the wire and stay stable across
-    /// the client's display-unit picker.
-    pub fn label(&self) -> &'static str {
-        match self {
-            Self::TimeNs => "ns",
-            Self::Bytes => "bytes",
-            Self::Ratio => "ratio",
-            Self::Count => "count",
-            Self::ThroughputMbS => "MB/s",
-        }
-    }
-}
-
-/// Engine/format tag for one series. Both fields are optional because not
-/// every fact table records both dimensions: `query_measurements` carries
-/// engine + format, while `compression_*` and `random_access_times` only
-/// carry format. Vector-search series have neither and are omitted from the
-/// map entirely.
-#[derive(Debug, Default, Clone, Serialize)]
-pub struct SeriesTag {
-    /// Query engine name, e.g. `duckdb` or `datafusion`.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub engine: Option<String>,
-    /// Physical format name, e.g. `vortex-file-compressed` or `parquet`.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub format: Option<String>,
-}
-
-/// Universe of engine + format chips the global filter bar can toggle.
-/// Returned as a separate, cheap-to-compute summary so the landing page can
-/// render the bar without iterating every chart payload.
-#[derive(Debug, Default, Serialize)]
-pub struct FilterUniverse {
-    /// Distinct engine names observed in `query_measurements`.
-    pub engines: Vec<String>,
-    /// Distinct format names observed across every fact table that records
-    /// one (excluding `vector_search_runs`).
-    pub formats: Vec<String>,
-}
-
-/// One row of the `commits[]` array on a [`ChartResponse`]. Carries enough
-/// metadata for the tooltip and the click-to-PR handler in `chart-init.js`.
-#[derive(Debug, Clone, Serialize)]
-pub struct CommitPoint {
-    /// Full git SHA of the commit.
-    pub sha: String,
-    /// Commit timestamp as ISO-8601 / RFC 3339.
-    pub timestamp: String,
-    /// First-line commit message (or the full message if no newline).
-    pub message: String,
-    /// GitHub commit URL - used as the fallback when no `(#NNNN)` is present.
-    pub url: String,
-}
-
-/// Body of `GET /health`: liveness probe plus a row-count rollup that's
-/// useful for "did my ingest land?" smoke tests.
-#[derive(Debug, Serialize)]
-pub struct HealthResponse {
-    /// Always `"ok"` when the server is reachable.
-    pub status: &'static str,
-    /// Path to the DuckDB file the server is serving from.
-    pub db_path: String,
-    /// Schema version the server was compiled against.
-    pub schema_version: i32,
-    /// Full 40-hex git SHA the binary was built from, or `"unknown"`
-    /// outside a git checkout. Matches the value the deploy timer
-    /// writes to `/var/lib/vortex-bench/last-deployed-sha` byte-for-byte;
-    /// operators can compare the two directly (no truncation) to
-    /// confirm the live process is the one the deploy timer last
-    /// rolled out.
-    pub build_sha: &'static str,
-    /// Most recent `commits.timestamp`, or `None` if the table is empty.
-    pub latest_commit_timestamp: Option<String>,
-    /// Per-fact-table row counts for smoke tests.
-    /// Per-table row counts surfaced for smoke tests. Keys are table names
-    /// (`commits` plus one entry per [`crate::family::Family::table_name`]).
-    /// Serialized as a JSON object so the wire shape (`row_counts.commits`,
-    /// `row_counts.query_measurements`, etc.) is unchanged from the
-    /// fixed-struct version this map replaced; consumers that index in by
-    /// key keep working. `BTreeMap` preserves a stable key order in JSON.
-    pub row_counts: std::collections::BTreeMap<&'static str, i64>,
-}
diff --git a/benchmarks-website/server/src/api/filter.rs b/benchmarks-website/server/src/api/filter.rs
deleted file mode 100644
index 56ee2a16379..00000000000
--- a/benchmarks-website/server/src/api/filter.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Filter chip universe — distinct engines and formats observed across the
-//! fact tables, surfaced to the global filter bar.
-
-use std::collections::BTreeSet;
-
-use anyhow::Result;
-use duckdb::Connection;
-
-use super::dto::FilterUniverse;
-
-/// Collect the set of distinct engines and formats observed across the fact
-/// tables. Used by the landing page to seed the global filter bar's chip
-/// universe, so adding a new engine or format in ingest automatically
-/// surfaces a chip without a code change.
-///
-/// Engines come from `query_measurements` only — the other fact tables don't
-/// record an engine. Formats are unioned across `query_measurements`,
-/// `compression_times`, `compression_sizes`, and `random_access_times`;
-/// `vector_search_runs` is intentionally excluded because its `flavor`
-/// column is not a format in the same sense the chip filter is matching on.
-pub fn collect_filter_universe(conn: &Connection) -> Result<FilterUniverse> {
-    let mut engines: BTreeSet<String> = BTreeSet::new();
-    let mut formats: BTreeSet<String> = BTreeSet::new();
-
-    let mut stmt =
-        conn.prepare("SELECT DISTINCT engine FROM query_measurements WHERE engine IS NOT NULL")?;
-    for row in stmt.query_map([], |r| r.get::<_, String>(0))? {
-        engines.insert(row?);
-    }
-
-    for sql in [
-        "SELECT DISTINCT format FROM query_measurements   WHERE format IS NOT NULL",
-        "SELECT DISTINCT format FROM compression_times    WHERE format IS NOT NULL",
-        "SELECT DISTINCT format FROM compression_sizes    WHERE format IS NOT NULL",
-        "SELECT DISTINCT format FROM random_access_times  WHERE format IS NOT NULL",
-    ] {
-        let mut stmt = conn.prepare(sql)?;
-        for row in stmt.query_map([], |r| r.get::<_, String>(0))? {
-            formats.insert(row?);
-        }
-    }
-
-    Ok(FilterUniverse {
-        engines: engines.into_iter().collect(),
-        formats: formats.into_iter().collect(),
-    })
-}
diff --git a/benchmarks-website/server/src/api/groups.rs b/benchmarks-website/server/src/api/groups.rs
deleted file mode 100644
index 9490404621f..00000000000
--- a/benchmarks-website/server/src/api/groups.rs
+++ /dev/null
@@ -1,348 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Group + chart-link discovery from the five fact tables.
-//!
-//! `collect_groups` is the entry point: it scans every fact table to find
-//! distinct group dimensions, materialises [`super::dto::Group`] records,
-//! attaches their summaries, and applies the canonical [`super::dto::GROUP_ORDER`].
-
-use anyhow::Context as _;
-use anyhow::Result;
-use duckdb::Connection;
-
-use super::descriptions::group_description;
-use super::dto::ChartLink;
-use super::dto::Group;
-use super::dto::group_sort_key;
-use super::summary::collect_group_summary;
-use crate::slug::ChartKey;
-use crate::slug::GroupKey;
-
-/// Collect every group + chart link derivable from the data. Used by both
-/// `GET /api/groups` and the HTML landing page.
-///
-/// Iterates the per-fact-table [`crate::family::FAMILIES`] registry rather
-/// than spelling out the five `collect_*_group(s)` calls inline - adding a
-/// sixth fact table only requires one new const in `family.rs`.
-pub(crate) fn collect_groups(conn: &Connection) -> Result<Vec<Group>> {
-    let mut groups: Vec<Group> = Vec::new();
-
-    for family in crate::family::FAMILIES {
-        let family_groups = (family.collect_groups)(conn)
-            .with_context(|| format!("collect_groups for {}", family.table_name))?;
-        groups.extend(family_groups);
-    }
-
-    for group in &mut groups {
-        let key = GroupKey::from_slug(&group.slug)
-            .with_context(|| format!("invalid generated group slug: {}", group.slug))?;
-        group.summary = collect_group_summary(conn, &key, &group.charts)?;
-        group.description = group_description(&group.name);
-    }
-
-    // Apply canonical ordering. `sort_by_key` is stable, so groups whose
-    // names map to the same key (the `GROUP_ORDER.len()` bucket - i.e. not in
-    // the canonical list) keep the order the discovery passes produced.
-    groups.sort_by(|a, b| group_sort_key(&a.name).cmp(&group_sort_key(&b.name)));
-
-    Ok(groups)
-}
-
-pub(crate) fn collect_query_groups(conn: &Connection) -> Result<Vec<Group>> {
-    let mut stmt = conn.prepare(
-        r#"
-        SELECT dataset, dataset_variant, scale_factor, storage, query_idx
-          FROM query_measurements
-         GROUP BY dataset, dataset_variant, scale_factor, storage, query_idx
-         ORDER BY dataset, dataset_variant NULLS FIRST,
-                  scale_factor NULLS FIRST, storage, query_idx
-        "#,
-    )?;
-    let rows = stmt.query_map([], |row| {
-        Ok((
-            row.get::<_, String>(0)?,
-            row.get::<_, Option<String>>(1)?,
-            row.get::<_, Option<String>>(2)?,
-            row.get::<_, String>(3)?,
-            row.get::<_, i32>(4)?,
-        ))
-    })?;
-
-    let mut groups: Vec<Group> = Vec::new();
-    let mut current: Option<(String, Option<String>, Option<String>, String)> = None;
-    for row in rows {
-        let (dataset, dataset_variant, scale_factor, storage, query_idx) = row?;
-        let key = (
-            dataset.clone(),
-            dataset_variant.clone(),
-            scale_factor.clone(),
-            storage.clone(),
-        );
-        let need_new_group = current.as_ref() != Some(&key);
-        if need_new_group {
-            let group_slug = GroupKey::QueryGroup {
-                dataset: dataset.clone(),
-                dataset_variant: dataset_variant.clone(),
-                scale_factor: scale_factor.clone(),
-                storage: storage.clone(),
-            }
-            .to_slug();
-            groups.push(Group {
-                name: group_name_query(&dataset, &dataset_variant, &scale_factor, &storage),
-                slug: group_slug,
-                charts: Vec::new(),
-                summary: None,
-                description: None,
-            });
-            current = Some(key);
-        }
-        let slug = ChartKey::QueryMeasurement {
-            dataset,
-            dataset_variant,
-            scale_factor,
-            storage,
-            query_idx,
-        }
-        .to_slug();
-        groups
-            .last_mut()
-            .expect("just pushed")
-            .charts
-            .push(ChartLink {
-                name: format!("Q{query_idx}"),
-                slug,
-            });
-    }
-    Ok(groups)
-}
-
-/// Render a query group name in the same shape v2 used (per the hard-coded
-/// list in `origin/ct/vfvb:benchmarks-website/index.html`):
-///
-/// - `tpch` + storage + scale_factor → `TPC-H (NVMe) (SF=1)`
-/// - `tpcds` + storage + scale_factor → `TPC-DS (NVMe) (SF=1)`
-/// - `clickbench` → `Clickbench`
-/// - anything else → fall back to the legacy `dataset[/variant] sf=N [storage]`
-///   shape so unknown datasets still get a deterministic name.
-///
-/// Variant disambiguation: for tpch/tpcds, if `dataset_variant` is set we
-/// append ` / variant`, since v2's list flattened variants but v3 ingests
-/// them. Without this, two ingestion variants would collide.
-fn group_name_query(
-    dataset: &str,
-    dataset_variant: &Option<String>,
-    scale_factor: &Option<String>,
-    storage: &str,
-) -> String {
-    let storage_label = match storage {
-        "nvme" => Some("NVMe"),
-        "s3" => Some("S3"),
-        _ => None,
-    };
-    let base = match (dataset, storage_label, scale_factor.as_deref()) {
-        ("tpch", Some(s), Some(sf)) => Some(format!("TPC-H ({s}) (SF={sf})")),
-        ("tpcds", Some(s), Some(sf)) => Some(format!("TPC-DS ({s}) (SF={sf})")),
-        ("clickbench", ..) => Some("Clickbench".to_string()),
-        _ => None,
-    };
-    if let Some(mut name) = base {
-        if let Some(v) = dataset_variant {
-            name.push_str(" / ");
-            name.push_str(v);
-        }
-        return name;
-    }
-    // Legacy fallback for unknown datasets - keeps the page rendering rather
-    // than silently dropping data.
-    let mut name = dataset.to_string();
-    if let Some(v) = dataset_variant {
-        name.push('/');
-        name.push_str(v);
-    }
-    if let Some(sf) = scale_factor {
-        name.push_str(" sf=");
-        name.push_str(sf);
-    }
-    name.push_str(" [");
-    name.push_str(storage);
-    name.push(']');
-    name
-}
-
-pub(crate) fn collect_compression_time_group(conn: &Connection) -> Result<Option<Group>> {
-    let mut stmt = conn.prepare(
-        r#"
-        SELECT dataset, dataset_variant
-          FROM compression_times
-         GROUP BY dataset, dataset_variant
-         ORDER BY dataset, dataset_variant NULLS FIRST
-        "#,
-    )?;
-    let charts: Vec<ChartLink> = stmt
-        .query_map([], |row| {
-            let dataset: String = row.get(0)?;
-            let dataset_variant: Option<String> = row.get(1)?;
-            Ok((dataset, dataset_variant))
-        })?
-        .map(|r| {
-            r.map(|(dataset, dataset_variant)| {
-                let key = ChartKey::CompressionTime {
-                    dataset: dataset.clone(),
-                    dataset_variant: dataset_variant.clone(),
-                };
-                let mut name = dataset;
-                if let Some(v) = &dataset_variant {
-                    name.push('/');
-                    name.push_str(v);
-                }
-                ChartLink {
-                    name,
-                    slug: key.to_slug(),
-                }
-            })
-        })
-        .collect::<Result<_, _>>()?;
-    if charts.is_empty() {
-        Ok(None)
-    } else {
-        Ok(Some(Group {
-            name: "Compression".into(),
-            slug: GroupKey::CompressionTimeGroup.to_slug(),
-            charts,
-            summary: None,
-            description: None,
-        }))
-    }
-}
-
-pub(crate) fn collect_compression_size_group(conn: &Connection) -> Result<Option<Group>> {
-    let mut stmt = conn.prepare(
-        r#"
-        SELECT dataset, dataset_variant
-          FROM compression_sizes
-         GROUP BY dataset, dataset_variant
-         ORDER BY dataset, dataset_variant NULLS FIRST
-        "#,
-    )?;
-    let charts: Vec<ChartLink> = stmt
-        .query_map([], |row| {
-            let dataset: String = row.get(0)?;
-            let dataset_variant: Option<String> = row.get(1)?;
-            Ok((dataset, dataset_variant))
-        })?
-        .map(|r| {
-            r.map(|(dataset, dataset_variant)| {
-                let key = ChartKey::CompressionSize {
-                    dataset: dataset.clone(),
-                    dataset_variant: dataset_variant.clone(),
-                };
-                let mut name = dataset;
-                if let Some(v) = &dataset_variant {
-                    name.push('/');
-                    name.push_str(v);
-                }
-                ChartLink {
-                    name,
-                    slug: key.to_slug(),
-                }
-            })
-        })
-        .collect::<Result<_, _>>()?;
-    if charts.is_empty() {
-        Ok(None)
-    } else {
-        Ok(Some(Group {
-            name: "Compression Size".into(),
-            slug: GroupKey::CompressionSizeGroup.to_slug(),
-            charts,
-            summary: None,
-            description: None,
-        }))
-    }
-}
-
-pub(crate) fn collect_random_access_group(conn: &Connection) -> Result<Option<Group>> {
-    let mut stmt = conn.prepare(
-        r#"
-        SELECT DISTINCT dataset
-          FROM random_access_times
-         ORDER BY dataset
-        "#,
-    )?;
-    let charts: Vec<ChartLink> = stmt
-        .query_map([], |row| row.get::<_, String>(0))?
-        .map(|r| {
-            r.map(|dataset| ChartLink {
-                name: dataset.clone(),
-                slug: ChartKey::RandomAccess { dataset }.to_slug(),
-            })
-        })
-        .collect::<Result<_, _>>()?;
-    if charts.is_empty() {
-        Ok(None)
-    } else {
-        Ok(Some(Group {
-            name: "Random Access".into(),
-            slug: GroupKey::RandomAccessGroup.to_slug(),
-            charts,
-            summary: None,
-            description: None,
-        }))
-    }
-}
-
-pub(crate) fn collect_vector_search_groups(conn: &Connection) -> Result<Vec<Group>> {
-    let mut stmt = conn.prepare(
-        r#"
-        SELECT dataset, layout, threshold
-          FROM vector_search_runs
-         GROUP BY dataset, layout, threshold
-         ORDER BY dataset, layout, threshold
-        "#,
-    )?;
-    let rows = stmt.query_map([], |row| {
-        Ok((
-            row.get::<_, String>(0)?,
-            row.get::<_, String>(1)?,
-            row.get::<_, f64>(2)?,
-        ))
-    })?;
-
-    let mut groups: Vec<Group> = Vec::new();
-    let mut current: Option<(String, String)> = None;
-    for row in rows {
-        let (dataset, layout, threshold) = row?;
-        let key = (dataset.clone(), layout.clone());
-        if current.as_ref() != Some(&key) {
-            let group_slug = GroupKey::VectorSearchGroup {
-                dataset: dataset.clone(),
-                layout: layout.clone(),
-            }
-            .to_slug();
-            groups.push(Group {
-                name: format!("{dataset} / {layout}"),
-                slug: group_slug,
-                charts: Vec::new(),
-                summary: None,
-                description: None,
-            });
-            current = Some(key);
-        }
-        let slug = ChartKey::VectorSearch {
-            dataset,
-            layout,
-            threshold,
-        }
-        .to_slug();
-        groups
-            .last_mut()
-            .expect("just pushed")
-            .charts
-            .push(ChartLink {
-                name: format!("threshold={threshold}"),
-                slug,
-            });
-    }
-    Ok(groups)
-}
diff --git a/benchmarks-website/server/src/api/mod.rs b/benchmarks-website/server/src/api/mod.rs
deleted file mode 100644
index aabc7616ab4..00000000000
--- a/benchmarks-website/server/src/api/mod.rs
+++ /dev/null
@@ -1,274 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Read-side API: `/api/groups`, `/api/chart/{slug}`, `/api/group/{slug}`,
-//! `/health`.
-//!
-//! Group / chart / series fit follows the layout in [`crate::schema`]:
-//! one fact table per measurement family, each with a known group / chart /
-//! series tuple. Slugs round-trip through [`crate::slug::ChartKey`] and
-//! [`crate::slug::GroupKey`].
-//!
-//! Submodules:
-//! - [`mod@dto`]          — every wire-shape struct (`Group`, `ChartResponse`, …).
-//! - [`mod@window`]       — [`CommitWindow`] + [`ChartQuery`].
-//! - [`mod@groups`]       — discovery passes that build the group / chart-link tree.
-//! - [`mod@summary`]      — v2-compatible per-group rollups.
-//! - [`mod@charts`]       — `chart_payload` + the per-fact-table `collect_*_chart`
-//!   functions and their shared `SeriesAccumulator`.
-//! - [`mod@filter`]       — chip-universe collection for the global filter bar.
-//! - [`mod@descriptions`] — editorial blurbs surfaced as hover tooltips.
-
-pub mod charts;
-pub mod descriptions;
-pub mod dto;
-pub mod filter;
-pub mod groups;
-pub mod summary;
-pub mod window;
-
-use anyhow::Result;
-use axum::Json;
-use axum::extract::Path;
-use axum::extract::Query;
-use axum::extract::State;
-use axum::http::HeaderMap;
-use axum::response::IntoResponse;
-use axum::response::Response;
-use duckdb::Connection;
-
-pub(crate) use self::charts::chart_payload;
-pub(crate) use self::charts::collect_group_charts;
-pub use self::dto::ChartHistory;
-pub use self::dto::ChartLink;
-pub use self::dto::ChartResponse;
-pub use self::dto::CommitPoint;
-pub use self::dto::DEFAULT_COMMIT_WINDOW;
-pub use self::dto::FilterUniverse;
-pub use self::dto::GROUP_ORDER;
-pub use self::dto::Group;
-pub use self::dto::GroupChartsResponse;
-pub use self::dto::GroupsResponse;
-pub use self::dto::HealthResponse;
-pub use self::dto::NamedChartResponse;
-pub use self::dto::QueryRanking;
-pub use self::dto::RandomAccessRanking;
-pub use self::dto::SeriesTag;
-pub use self::dto::Summary;
-pub use self::dto::UnitKind;
-pub use self::dto::group_sort_key;
-pub use self::filter::collect_filter_universe;
-pub(crate) use self::groups::collect_groups;
-pub use self::window::ChartQuery;
-pub use self::window::CommitWindow;
-use crate::app::AppState;
-use crate::db;
-use crate::error::ApiError;
-use crate::read_model::ArtifactCachePolicy;
-use crate::slug::ChartKey;
-use crate::slug::GroupKey;
-
-pub(crate) fn read_transaction<T>(
-    conn: &mut Connection,
-    f: impl FnOnce(&Connection) -> Result<T>,
-) -> Result<T> {
-    conn.execute_batch("BEGIN TRANSACTION")?;
-    let result = f(conn);
-    match result {
-        Ok(value) => {
-            conn.execute_batch("COMMIT")?;
-            Ok(value)
-        }
-        Err(err) => {
-            let _ = conn.execute_batch("ROLLBACK");
-            Err(err)
-        }
-    }
-}
-
-/// Handler for `GET /api/groups`.
-pub async fn groups(
-    State(state): State<AppState>,
-    headers: HeaderMap,
-) -> Result<Response, ApiError> {
-    let generation = state.read_store.active();
-    Ok(generation
-        .groups_artifact()
-        .response(&headers, ArtifactCachePolicy::Revalidate))
-}
-
-/// Handler for `GET /api/chart/{slug}`.
-pub async fn chart(
-    State(state): State<AppState>,
-    Path(slug): Path<String>,
-    Query(q): Query<ChartQuery>,
-    headers: HeaderMap,
-) -> Result<Response, ApiError> {
-    let key = ChartKey::from_slug(&slug)
-        .map_err(|e| ApiError::BadRequest(format!("invalid slug: {e}")))?;
-    let window = q.window();
-    if is_materialized_window(&window) {
-        let generation = state.read_store.active();
-        let response = generation
-            .chart_artifact(&slug)
-            .ok_or_else(|| ApiError::NotFound(format!("no data for slug {slug:?}")))?;
-        return Ok(response.response(&headers, ArtifactCachePolicy::Revalidate));
-    }
-    let response = cached_chart_payload(&state, &slug, &key, &window).await?;
-    let response =
-        response.ok_or_else(|| ApiError::NotFound(format!("no data for slug {slug:?}")))?;
-    Ok(Json(response).into_response())
-}
-
-/// Handler for `GET /api/group/{slug}`.
-pub async fn group(
-    State(state): State<AppState>,
-    Path(slug): Path<String>,
-    Query(q): Query<ChartQuery>,
-    headers: HeaderMap,
-) -> Result<Response, ApiError> {
-    let key = GroupKey::from_slug(&slug)
-        .map_err(|e| ApiError::BadRequest(format!("invalid group slug: {e}")))?;
-    let window = q.window();
-    if is_materialized_window(&window) {
-        let generation = state.read_store.active();
-        let response = generation
-            .group_artifact(&slug)
-            .ok_or_else(|| ApiError::NotFound(format!("no data for group slug {slug:?}")))?;
-        return Ok(response.response(&headers, ArtifactCachePolicy::Revalidate));
-    }
-    let response = cached_group_charts(&state, &slug, &key, &window).await?;
-    let response =
-        response.ok_or_else(|| ApiError::NotFound(format!("no data for group slug {slug:?}")))?;
-    Ok(Json(response).into_response())
-}
-
-/// Handler for versioned latest-100 group shard artifacts.
-pub async fn group_shard_artifact(
-    State(state): State<AppState>,
-    Path((generation_id, group_slug, index)): Path<(String, String, usize)>,
-    headers: HeaderMap,
-) -> Result<Response, ApiError> {
-    let generation = state
-        .read_store
-        .generation(&generation_id)
-        .ok_or_else(|| ApiError::NotFound(format!("unknown generation {generation_id:?}")))?;
-    let artifact = generation
-        .group_shard_artifact(&group_slug, index)
-        .ok_or_else(|| ApiError::NotFound(format!("unknown group shard {group_slug:?}#{index}")))?;
-    Ok(artifact.response(&headers, ArtifactCachePolicy::Immutable))
-}
-
-fn is_materialized_window(window: &CommitWindow) -> bool {
-    matches!(window, CommitWindow::Last(n) if n.get() == DEFAULT_COMMIT_WINDOW)
-}
-
-/// Cache-aware wrapper around `collect_groups`.
-pub async fn cached_groups(state: &AppState) -> Result<std::sync::Arc<Vec<Group>>> {
-    let db = state.db.clone();
-    state
-        .cache
-        .groups(move || async move {
-            db::run_read_blocking(&db, |conn| read_transaction(conn, collect_groups)).await
-        })
-        .await
-}
-
-/// Cache-aware wrapper around [`collect_filter_universe`].
-pub async fn cached_filter_universe(state: &AppState) -> Result<std::sync::Arc<FilterUniverse>> {
-    let db = state.db.clone();
-    state
-        .cache
-        .filter_universe(move || async move {
-            db::run_read_blocking(&db, |conn| read_transaction(conn, collect_filter_universe)).await
-        })
-        .await
-}
-
-/// Cache-aware wrapper around `chart_payload`.
-pub async fn cached_chart_payload(
-    state: &AppState,
-    slug: &str,
-    key: &ChartKey,
-    window: &CommitWindow,
-) -> Result<Option<std::sync::Arc<ChartResponse>>> {
-    let db = state.db.clone();
-    let key_for_compute = key.clone();
-    let window_for_compute = *window;
-    state
-        .cache
-        .chart_payload(slug, window, move || async move {
-            db::run_read_blocking(&db, move |conn| {
-                read_transaction(conn, |conn| {
-                    chart_payload(conn, &key_for_compute, &window_for_compute)
-                })
-            })
-            .await
-        })
-        .await
-}
-
-/// Cache-aware wrapper around `collect_group_charts`.
-pub async fn cached_group_charts(
-    state: &AppState,
-    slug: &str,
-    key: &GroupKey,
-    window: &CommitWindow,
-) -> Result<Option<std::sync::Arc<GroupChartsResponse>>> {
-    let db = state.db.clone();
-    let key_for_compute = key.clone();
-    let window_for_compute = *window;
-    state
-        .cache
-        .group_charts(slug, window, move || async move {
-            db::run_read_blocking(&db, move |conn| {
-                read_transaction(conn, |conn| {
-                    collect_group_charts(conn, &key_for_compute, &window_for_compute)
-                })
-            })
-            .await
-        })
-        .await
-}
-
-/// Handler for `GET /health`.
-pub async fn health(State(state): State<AppState>) -> Result<impl IntoResponse, ApiError> {
-    let path = state.db_path.display().to_string();
-    let response = db::run_read_blocking(&state.db, move |conn| {
-        read_transaction(conn, |conn| collect_health(conn, path))
-    })
-    .await?;
-    Ok(Json(response))
-}
-
-fn collect_health(conn: &Connection, db_path: String) -> Result<HealthResponse> {
-    let count = |table: &str| -> Result<i64> {
-        let sql = format!("SELECT COUNT(*) FROM {table}");
-        let n: i64 = conn.query_row(&sql, [], |r| r.get(0))?;
-        Ok(n)
-    };
-    let mut row_counts: std::collections::BTreeMap<&'static str, i64> =
-        std::collections::BTreeMap::new();
-    // `commits` dim table first; every fact family then surfaces via its
-    // registry entry. Adding a sixth fact table appends one entry to
-    // [`crate::family::FAMILIES`] and `/health` picks it up automatically.
-    row_counts.insert("commits", count("commits")?);
-    for family in crate::family::FAMILIES {
-        row_counts.insert(family.table_name, (family.row_count)(conn)?);
-    }
-    let latest_commit_timestamp: Option<String> = conn
-        .query_row(
-            "SELECT CAST(timestamp AS VARCHAR) FROM commits ORDER BY timestamp DESC LIMIT 1",
-            [],
-            |r| r.get::<_, String>(0),
-        )
-        .ok();
-    Ok(HealthResponse {
-        status: "ok",
-        db_path,
-        schema_version: crate::schema::SCHEMA_VERSION,
-        build_sha: env!("VORTEX_BENCH_BUILD_SHA"),
-        latest_commit_timestamp,
-        row_counts,
-    })
-}
diff --git a/benchmarks-website/server/src/api/summary.rs b/benchmarks-website/server/src/api/summary.rs
deleted file mode 100644
index 8c835a7c0e2..00000000000
--- a/benchmarks-website/server/src/api/summary.rs
+++ /dev/null
@@ -1,377 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! v2-compatible group summary rollups.
-//!
-//! Each `collect_*_summary` runs a small set of focused SQL queries over a
-//! single fact table and returns one [`Summary`] variant. The query group
-//! summary is gated on a v2 dataset allowlist via
-//! `query_group_has_v2_summary`.
-
-use std::collections::BTreeMap;
-use std::collections::BTreeSet;
-
-use anyhow::Context as _;
-use anyhow::Result;
-use duckdb::Connection;
-use duckdb::ToSql;
-use duckdb::params_from_iter;
-
-use super::dto::ChartLink;
-use super::dto::QueryRanking;
-use super::dto::RandomAccessRanking;
-use super::dto::Summary;
-use crate::slug::GroupKey;
-
-/// Compute the v2-compatible summary for one group, if its kind has one.
-pub(crate) fn collect_group_summary(
-    conn: &Connection,
-    key: &GroupKey,
-    charts: &[ChartLink],
-) -> Result<Option<Summary>> {
-    match key {
-        GroupKey::QueryGroup {
-            dataset,
-            dataset_variant,
-            scale_factor,
-            storage,
-        } if query_group_has_v2_summary(dataset) => {
-            collect_query_summary(conn, dataset, dataset_variant, scale_factor, storage)
-        }
-        GroupKey::QueryGroup { .. } => Ok(None),
-        GroupKey::CompressionTimeGroup => collect_compression_summary(conn),
-        GroupKey::CompressionSizeGroup => collect_compression_size_summary(conn),
-        GroupKey::RandomAccessGroup => collect_random_access_summary(conn, charts),
-        GroupKey::VectorSearchGroup { .. } => Ok(None),
-    }
-}
-
-fn query_group_has_v2_summary(dataset: &str) -> bool {
-    matches!(
-        dataset,
-        "clickbench" | "statpopgen" | "polarsignals" | "tpch" | "tpcds"
-    )
-}
-
-fn collect_random_access_summary(
-    conn: &Connection,
-    charts: &[ChartLink],
-) -> Result<Option<Summary>> {
-    for chart in charts {
-        let mut stmt = conn.prepare(
-            r#"
-            SELECT r.format, CAST(r.value_ns AS DOUBLE)
-              FROM random_access_times r
-              JOIN commits c USING (commit_sha)
-             WHERE r.dataset = ?
-               AND r.value_ns > 0
-               AND c.timestamp = (
-                    SELECT MAX(c2.timestamp)
-                      FROM random_access_times r2
-                      JOIN commits c2 USING (commit_sha)
-                     WHERE r2.dataset = ?
-                       AND r2.value_ns > 0
-               )
-             ORDER BY r.value_ns, r.format
-            "#,
-        )?;
-        let rows = stmt.query_map([chart.name.as_str(), chart.name.as_str()], |row| {
-            Ok(RandomAccessRanking {
-                name: row.get(0)?,
-                time: row.get(1)?,
-                ratio: 0.0,
-            })
-        })?;
-        let mut rankings = rows.collect::<Result<Vec<_>, _>>()?;
-        let Some(min_time) = rankings.iter().map(|r| r.time).reduce(f64::min) else {
-            continue;
-        };
-        if min_time <= 0.0 || !min_time.is_finite() {
-            continue;
-        }
-        for r in &mut rankings {
-            r.ratio = r.time / min_time;
-        }
-        rankings.sort_by(|a, b| a.time.total_cmp(&b.time).then_with(|| a.name.cmp(&b.name)));
-        return Ok(Some(Summary::RandomAccess {
-            title: "Random Access Performance",
-            rankings,
-            explanation: "Random access time | Ratio to fastest (lower is better)",
-        }));
-    }
-    Ok(None)
-}
-
-fn collect_compression_summary(conn: &Connection) -> Result<Option<Summary>> {
-    let timestamp = match latest_compression_ratio_timestamp(conn, "encode")? {
-        Some(ts) => ts,
-        None => match latest_compression_ratio_timestamp(conn, "decode")? {
-            Some(ts) => ts,
-            None => return Ok(None),
-        },
-    };
-
-    let compress = compression_speedups_at(conn, "encode", &timestamp)?;
-    let decompress = compression_speedups_at(conn, "decode", &timestamp)?;
-    if compress.is_empty() && decompress.is_empty() {
-        return Ok(None);
-    }
-
-    Ok(Some(Summary::Compression {
-        title: "Compression Throughput vs Parquet",
-        compress_ratio: geo_mean(&compress),
-        decompress_ratio: geo_mean(&decompress),
-        dataset_count: compress.len(),
-        explanation: "Inverse geomean of Vortex/Parquet ratios (higher is better)",
-    }))
-}
-
-fn latest_compression_ratio_timestamp(conn: &Connection, op: &str) -> Result<Option<String>> {
-    conn.query_row(
-        r#"
-        SELECT CAST(MAX(ts) AS VARCHAR)
-          FROM (
-            SELECT c.timestamp AS ts
-              FROM compression_times v
-              JOIN compression_times p
-                ON p.commit_sha = v.commit_sha
-               AND p.dataset = v.dataset
-               AND p.dataset_variant IS NOT DISTINCT FROM v.dataset_variant
-               AND p.op = v.op
-              JOIN commits c ON c.commit_sha = v.commit_sha
-             WHERE v.op = ?
-               AND v.format = 'vortex-file-compressed'
-               AND p.format = 'parquet'
-               AND v.value_ns > 0
-               AND p.value_ns > 0
-               AND lower(v.dataset) NOT LIKE '%wide table%'
-          )
-        "#,
-        [op],
-        |row| row.get(0),
-    )
-    .context("latest compression ratio timestamp")
-}
-
-fn compression_speedups_at(conn: &Connection, op: &str, timestamp: &str) -> Result<Vec<f64>> {
-    let mut stmt = conn.prepare(
-        r#"
-        SELECT CAST(p.value_ns AS DOUBLE) / CAST(v.value_ns AS DOUBLE)
-          FROM compression_times v
-          JOIN compression_times p
-            ON p.commit_sha = v.commit_sha
-           AND p.dataset = v.dataset
-           AND p.dataset_variant IS NOT DISTINCT FROM v.dataset_variant
-           AND p.op = v.op
-          JOIN commits c ON c.commit_sha = v.commit_sha
-         WHERE v.op = ?
-           AND v.format = 'vortex-file-compressed'
-           AND p.format = 'parquet'
-           AND v.value_ns > 0
-           AND p.value_ns > 0
-           AND lower(v.dataset) NOT LIKE '%wide table%'
-           AND c.timestamp = CAST(? AS TIMESTAMPTZ)
-         ORDER BY v.dataset, v.dataset_variant NULLS FIRST
-        "#,
-    )?;
-    let rows = stmt.query_map([op, timestamp], |row| row.get::<_, f64>(0))?;
-    rows.collect::<Result<_, _>>()
-        .context("compression speedups")
-}
-
-fn collect_compression_size_summary(conn: &Connection) -> Result<Option<Summary>> {
-    let Some(timestamp) = latest_compression_size_ratio_timestamp(conn)? else {
-        return Ok(None);
-    };
-    let ratios = compression_size_ratios_at(conn, &timestamp)?;
-    let Some(mean_ratio) = geo_mean(&ratios) else {
-        return Ok(None);
-    };
-    let min_ratio = ratios.iter().copied().fold(f64::INFINITY, f64::min);
-    let max_ratio = ratios.iter().copied().fold(f64::NEG_INFINITY, f64::max);
-
-    Ok(Some(Summary::CompressionSize {
-        title: "Compression Size Summary",
-        min_ratio,
-        mean_ratio,
-        max_ratio,
-        dataset_count: ratios.len(),
-        explanation: "Geomean of Vortex/Parquet size ratios (lower is better)",
-    }))
-}
-
-fn latest_compression_size_ratio_timestamp(conn: &Connection) -> Result<Option<String>> {
-    conn.query_row(
-        r#"
-        SELECT CAST(MAX(ts) AS VARCHAR)
-          FROM (
-            SELECT c.timestamp AS ts
-              FROM compression_sizes v
-              JOIN compression_sizes p
-                ON p.commit_sha = v.commit_sha
-               AND p.dataset = v.dataset
-               AND p.dataset_variant IS NOT DISTINCT FROM v.dataset_variant
-              JOIN commits c ON c.commit_sha = v.commit_sha
-             WHERE v.format = 'vortex-file-compressed'
-               AND p.format = 'parquet'
-               AND v.value_bytes > 0
-               AND p.value_bytes > 0
-               AND lower(v.dataset) NOT LIKE '%wide table%'
-          )
-        "#,
-        [],
-        |row| row.get(0),
-    )
-    .context("latest compression-size ratio timestamp")
-}
-
-fn compression_size_ratios_at(conn: &Connection, timestamp: &str) -> Result<Vec<f64>> {
-    let mut stmt = conn.prepare(
-        r#"
-        SELECT CAST(v.value_bytes AS DOUBLE) / CAST(p.value_bytes AS DOUBLE)
-          FROM compression_sizes v
-          JOIN compression_sizes p
-            ON p.commit_sha = v.commit_sha
-           AND p.dataset = v.dataset
-           AND p.dataset_variant IS NOT DISTINCT FROM v.dataset_variant
-          JOIN commits c ON c.commit_sha = v.commit_sha
-         WHERE v.format = 'vortex-file-compressed'
-           AND p.format = 'parquet'
-           AND v.value_bytes > 0
-           AND p.value_bytes > 0
-           AND lower(v.dataset) NOT LIKE '%wide table%'
-           AND c.timestamp = CAST(? AS TIMESTAMPTZ)
-         ORDER BY v.dataset, v.dataset_variant NULLS FIRST
-        "#,
-    )?;
-    let rows = stmt.query_map([timestamp], |row| row.get::<_, f64>(0))?;
-    rows.collect::<Result<_, _>>()
-        .context("compression size ratios")
-}
-
-fn collect_query_summary(
-    conn: &Connection,
-    dataset: &str,
-    dataset_variant: &Option<String>,
-    scale_factor: &Option<String>,
-    storage: &str,
-) -> Result<Option<Summary>> {
-    let mut stmt = conn.prepare(
-        r#"
-        WITH latest AS (
-            SELECT q.query_idx,
-                   q.engine || ':' || q.format AS series,
-                   CAST(q.value_ns AS DOUBLE) AS value_ns,
-                   row_number() OVER (
-                       PARTITION BY q.query_idx, q.engine, q.format
-                       ORDER BY c.timestamp DESC
-                   ) AS rn
-              FROM query_measurements q
-              JOIN commits c USING (commit_sha)
-             WHERE q.dataset = ?
-               AND q.dataset_variant IS NOT DISTINCT FROM ?
-               AND q.scale_factor    IS NOT DISTINCT FROM ?
-               AND q.storage = ?
-               AND q.value_ns > 0
-        )
-        SELECT query_idx, series, value_ns
-          FROM latest
-         WHERE rn = 1
-         ORDER BY query_idx, series
-        "#,
-    )?;
-    let binds: Vec<Box<dyn ToSql>> = vec![
-        Box::new(dataset.to_string()),
-        Box::new(dataset_variant.clone()),
-        Box::new(scale_factor.clone()),
-        Box::new(storage.to_string()),
-    ];
-    let rows = stmt.query_map(params_from_iter(binds.iter()), |row| {
-        Ok((
-            row.get::<_, i32>(0)?,
-            row.get::<_, String>(1)?,
-            row.get::<_, f64>(2)?,
-        ))
-    })?;
-
-    let mut queries = BTreeSet::new();
-    let mut values_by_series: BTreeMap<String, BTreeMap<i32, f64>> = BTreeMap::new();
-    for row in rows {
-        let (query_idx, series, value_ns) = row?;
-        queries.insert(query_idx);
-        values_by_series
-            .entry(series)
-            .or_default()
-            .insert(query_idx, value_ns);
-    }
-    if values_by_series.is_empty() {
-        return Ok(None);
-    }
-
-    let mut best_by_query: BTreeMap<i32, f64> = BTreeMap::new();
-    for query_idx in &queries {
-        let best = values_by_series
-            .values()
-            .filter_map(|series_values| series_values.get(query_idx).copied())
-            .fold(f64::INFINITY, f64::min);
-        if best.is_finite() {
-            best_by_query.insert(*query_idx, best);
-        }
-    }
-
-    let mut rankings = Vec::new();
-    for (name, query_values) in values_by_series {
-        let total_runtime: f64 = query_values.values().sum();
-        let max_runtime = query_values
-            .values()
-            .copied()
-            .fold(f64::NEG_INFINITY, f64::max);
-        if !max_runtime.is_finite() {
-            continue;
-        }
-        let penalty = max_runtime.max(300_000.0) * 2.0;
-        let ratios = queries
-            .iter()
-            .filter_map(|query_idx| {
-                let base = best_by_query.get(query_idx).copied()?;
-                let value = query_values.get(query_idx).copied().unwrap_or(penalty);
-                Some((10.0 + value) / (10.0 + base))
-            })
-            .collect::<Vec<_>>();
-        let Some(score) = geo_mean(&ratios) else {
-            continue;
-        };
-        rankings.push(QueryRanking {
-            name,
-            score,
-            total_runtime,
-        });
-    }
-    rankings.sort_by(|a, b| {
-        a.score
-            .total_cmp(&b.score)
-            .then_with(|| a.name.cmp(&b.name))
-    });
-
-    if rankings.is_empty() {
-        Ok(None)
-    } else {
-        Ok(Some(Summary::QueryBenchmark {
-            title: "Performance Summary",
-            rankings,
-            explanation: "Geomean of query time ratio to fastest (lower is better)",
-        }))
-    }
-}
-
-fn geo_mean(values: &[f64]) -> Option<f64> {
-    let mut sum_ln = 0.0;
-    let mut n = 0usize;
-    for value in values {
-        if *value > 0.0 && value.is_finite() {
-            sum_ln += value.ln();
-            n += 1;
-        }
-    }
-    (n > 0).then(|| (sum_ln / n as f64).exp())
-}
diff --git a/benchmarks-website/server/src/api/window.rs b/benchmarks-website/server/src/api/window.rs
deleted file mode 100644
index 167edf602ac..00000000000
--- a/benchmarks-website/server/src/api/window.rs
+++ /dev/null
@@ -1,201 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Server-side commit-window cap used by every chart query.
-//!
-//! Visual downsampling is the *client's* job (see
-//! `static/chart-init.js`) - this module only decides how many of the
-//! most recent commits to load from DuckDB.
-
-use std::num::NonZeroU32;
-
-use serde::Deserialize;
-
-use super::dto::DEFAULT_COMMIT_WINDOW;
-
-/// Largest numeric `?n=` accepted before clamping. `?n=all` remains the
-/// explicit opt-in for full history.
-pub(crate) const MAX_NUMERIC_COMMIT_WINDOW: u32 = 1_000;
-
-/// Server-side cap on how many of the most recent commits a chart includes.
-///
-/// `Last(n)` keeps the most recent `n` commits by `commits.timestamp`; `All`
-/// returns every commit ever ingested.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum CommitWindow {
-    /// Keep the most recent `n` commits.
-    Last(NonZeroU32),
-    /// No cap.
-    All,
-}
-
-impl Default for CommitWindow {
-    fn default() -> Self {
-        Self::Last(NonZeroU32::new(DEFAULT_COMMIT_WINDOW).expect("non-zero default"))
-    }
-}
-
-impl CommitWindow {
-    /// Parse the `?n=...` query string parameter. `None` and malformed values
-    /// fall back to [`CommitWindow::default`]. `"all"` (any case) means
-    /// unbounded. Numeric values are floored to `1` so `?n=0` becomes
-    /// `?n=1`, and values above `MAX_NUMERIC_COMMIT_WINDOW` are clamped.
-    /// Any further reduction in rendered point count happens client-side
-    /// (see `static/chart-init.js` for the LTTB pass on the visible
-    /// commit range).
-    pub fn parse(raw: Option<&str>) -> Self {
-        let Some(s) = raw else {
-            return Self::default();
-        };
-        let trimmed = s.trim();
-        if trimmed.eq_ignore_ascii_case("all") {
-            return Self::All;
-        }
-        trimmed
-            .parse::<u32>()
-            .ok()
-            .map(|v| v.clamp(1, MAX_NUMERIC_COMMIT_WINDOW))
-            .and_then(NonZeroU32::new)
-            .map(Self::Last)
-            .unwrap_or_default()
-    }
-
-    /// SQL fragment to splice into chart queries that filters `commits c` to
-    /// just the most recent `n` commits. Empty for `All`. The placeholder is
-    /// satisfied by [`Self::limit_param`] so the LIMIT value travels as a
-    /// bound parameter rather than an interpolated integer.
-    pub(crate) fn sql_filter(&self) -> &'static str {
-        match self {
-            Self::All => "",
-            Self::Last(_) => {
-                " AND c.commit_sha IN \
-                 (SELECT commit_sha FROM commits ORDER BY timestamp DESC, commit_sha DESC LIMIT ?)"
-            }
-        }
-    }
-
-    /// Bound parameter for the `LIMIT ?` placeholder produced by
-    /// [`Self::sql_filter`]. `None` for [`Self::All`] (no extra `?` to bind).
-    pub(crate) fn limit_param(&self) -> Option<i64> {
-        match self {
-            Self::All => None,
-            Self::Last(n) => Some(i64::from(n.get())),
-        }
-    }
-
-    /// Render this window as the value the URL would carry (`"100"` /
-    /// `"all"`). Used by the HTML toolbar to mark the active scope.
-    pub fn url_value(&self) -> String {
-        match self {
-            Self::All => "all".into(),
-            Self::Last(n) => n.get().to_string(),
-        }
-    }
-}
-
-/// Query string for `/api/chart/{slug}` and `/chart/{slug}`. Only `?n=`
-/// affects the JSON response; per-chart UI state (Y axis, slider) is local
-/// to `chart-init.js` and intentionally not in the URL.
-#[derive(Debug, Default, Deserialize)]
-pub struct ChartQuery {
-    /// Commit window: `25`, `50`, `100`, `250`, `all`, etc.
-    pub n: Option<String>,
-}
-
-impl ChartQuery {
-    /// Resolved [`CommitWindow`] from the raw `n` parameter.
-    pub fn window(&self) -> CommitWindow {
-        CommitWindow::parse(self.n.as_deref())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn commit_window_parse_defaults() {
-        let CommitWindow::Last(n) = CommitWindow::parse(None) else {
-            panic!("default should be Last");
-        };
-        assert_eq!(n.get(), DEFAULT_COMMIT_WINDOW);
-    }
-
-    #[test]
-    fn commit_window_parse_all() {
-        assert!(matches!(
-            CommitWindow::parse(Some("all")),
-            CommitWindow::All
-        ));
-        assert!(matches!(
-            CommitWindow::parse(Some("ALL")),
-            CommitWindow::All
-        ));
-        assert!(matches!(
-            CommitWindow::parse(Some(" all ")),
-            CommitWindow::All
-        ));
-    }
-
-    #[test]
-    fn commit_window_parse_numeric() {
-        let CommitWindow::Last(n) = CommitWindow::parse(Some("50")) else {
-            panic!()
-        };
-        assert_eq!(n.get(), 50);
-    }
-
-    #[test]
-    fn commit_window_parse_floors_zero_and_clamps_large_values() {
-        let CommitWindow::Last(n) = CommitWindow::parse(Some("99999")) else {
-            panic!()
-        };
-        assert_eq!(n.get(), 1_000);
-
-        // 0 floors to 1 since the underlying type is `NonZeroU32`.
-        let CommitWindow::Last(n) = CommitWindow::parse(Some("0")) else {
-            panic!("floor of 0 should round to 1")
-        };
-        assert_eq!(n.get(), 1);
-    }
-
-    #[test]
-    fn commit_window_parse_malformed_falls_back() {
-        let CommitWindow::Last(n) = CommitWindow::parse(Some("banana")) else {
-            panic!()
-        };
-        assert_eq!(n.get(), DEFAULT_COMMIT_WINDOW);
-        let CommitWindow::Last(n) = CommitWindow::parse(Some("")) else {
-            panic!()
-        };
-        assert_eq!(n.get(), DEFAULT_COMMIT_WINDOW);
-    }
-
-    #[test]
-    fn commit_window_url_value() {
-        assert_eq!(CommitWindow::default().url_value(), "100");
-        assert_eq!(CommitWindow::All.url_value(), "all");
-    }
-
-    #[test]
-    fn commit_window_sql_filter_shape() {
-        let CommitWindow::Last(n) = CommitWindow::parse(Some("42")) else {
-            panic!()
-        };
-        let f = CommitWindow::Last(n).sql_filter();
-        // Bound placeholder, not an interpolated integer.
-        assert!(f.contains("LIMIT ?"));
-        assert!(!f.contains("42"));
-        assert!(CommitWindow::All.sql_filter().is_empty());
-    }
-
-    #[test]
-    fn commit_window_limit_param() {
-        let CommitWindow::Last(n) = CommitWindow::parse(Some("42")) else {
-            panic!()
-        };
-        assert_eq!(CommitWindow::Last(n).limit_param(), Some(42));
-        assert_eq!(CommitWindow::All.limit_param(), None);
-        assert_eq!(CommitWindow::default().limit_param(), Some(100));
-    }
-}
diff --git a/benchmarks-website/server/src/app.rs b/benchmarks-website/server/src/app.rs
deleted file mode 100644
index 4060a5c7075..00000000000
--- a/benchmarks-website/server/src/app.rs
+++ /dev/null
@@ -1,257 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Axum [`Router`] composition and shared [`AppState`].
-//!
-//! The server serves two routers on two listeners in production:
-//!
-//! - **Public** ([`public_router`]) - `/api/groups`, `/api/chart/{slug}`,
-//!   `/api/group/{slug}`, `/api/ingest` (bearer-gated by
-//!   [`crate::auth::require_bearer`]), `/health`, plus HTML routes
-//!   contributed by [`crate::html::router`]. This is what
-//!   `VORTEX_BENCH_BIND` exposes (typically `0.0.0.0:3000`).
-//! - **Admin** ([`admin_router`]) - `/api/admin/snapshot`,
-//!   `/api/admin/sql`, both gated by [`crate::admin::require_admin_bearer`].
-//!   Only built when [`AppState::with_admin`] has been called. This is
-//!   what `VORTEX_BENCH_ADMIN_BIND` exposes (typically `127.0.0.1:3001`),
-//!   so admin endpoints never reach the public network even when the
-//!   public listener binds `0.0.0.0`.
-//!
-//! [`router`] still exists as a convenience for tests that don't care
-//! about the listener split: it merges public + admin onto a single
-//! router.
-//!
-//! All responses pass through [`CompressionLayer`] so HTML, JSON, and the
-//! bundled `/static/*` JS/CSS are served gzipped or brotli-encoded when the
-//! client advertises support. The landing page HTML alone is several
-//! hundred KB uncompressed, so this is the single biggest cold-load win.
-
-use std::path::Path;
-use std::path::PathBuf;
-use std::sync::Arc;
-
-use anyhow::Result;
-use anyhow::ensure;
-use axum::Router;
-use axum::extract::DefaultBodyLimit;
-use axum::routing::get;
-use axum::routing::post;
-use parking_lot::Mutex;
-use tower_http::compression::CompressionLayer;
-use vortex_utils::aliases::hash_set::HashSet;
-
-use crate::admin;
-use crate::api;
-use crate::auth::require_bearer;
-use crate::db::DbHandle;
-use crate::db::{self};
-use crate::html;
-use crate::ingest;
-use crate::query_cache::QueryCache;
-use crate::read_model::ReadStore;
-
-/// Route-local JSON body limit for CI ingest envelopes.
-///
-/// Axum's `Json` extractor defaults to 2 MiB, which is too small for larger
-/// benchmark matrices once `post-ingest.py` wraps a JSONL result file in one
-/// envelope. Keep this bounded rather than disabling the extractor limit.
-const INGEST_BODY_LIMIT_BYTES: usize = 64 * 1024 * 1024;
-
-/// Shared state for all handlers. Cheap to clone (everything is `Arc`-shaped
-/// or a small `String`).
-#[derive(Clone)]
-pub struct AppState {
-    /// Shared DuckDB handle. See [`crate::db`].
-    pub db: DbHandle,
-    /// Bearer token expected on `/api/ingest`. Compared via constant-time eq.
-    pub bearer_token: Arc<String>,
-    /// Bearer token expected on `/api/admin/*`. `None` disables the admin
-    /// router entirely. Set via [`AppState::with_admin`].
-    pub admin_bearer_token: Option<Arc<String>>,
-    /// On-disk path of the DuckDB file. Surfaced on `/health`.
-    pub db_path: Arc<PathBuf>,
-    /// In-memory cache of every read-side query result. Cleared by
-    /// [`crate::ingest`] after a successful commit. See [`crate::query_cache`].
-    pub cache: Arc<QueryCache>,
-    /// Materialized latest-100 read artifacts for the website hot path.
-    pub read_store: Arc<ReadStore>,
-    /// Directory `/api/admin/snapshot` writes per-table Vortex snapshots into
-    /// (`schema.sql` plus one `<table>.vortex` file per table in
-    /// [`crate::schema::TABLES`]). Defaults to `<db_path parent>/snapshots`.
-    /// Override via [`AppState::with_snapshot_dir`].
-    pub snapshot_dir: Arc<PathBuf>,
-    /// Directory DuckDB installs extensions into. Surfaced on `AppState` so
-    /// the operator can keep extensions on a writable filesystem path even
-    /// when systemd's `ProtectHome=read-only` blocks the default
-    /// `~/.duckdb/extensions/...`. Defaults to `<db_path parent>/duckdb-extensions`.
-    /// Override via [`AppState::with_extension_dir`].
-    pub extension_dir: Arc<PathBuf>,
-    /// Process-local reservation set for snapshot `ts` values currently being
-    /// written.
-    ///
-    /// Two concurrent `/api/admin/snapshot?ts=X` calls in the same process race
-    /// at the `tmp -> target` rename step; Linux `rename(2)` overwrites an
-    /// existing destination, so without this reservation the second call would
-    /// silently clobber the first. The set is consulted + populated atomically
-    /// in the snapshot handler before any disk work, and the entry is removed
-    /// whether the call succeeds or fails. Single `vortex-bench-server` process
-    /// per host is the supported deployment; cross-process race is out of scope
-    /// (`ensure_distinct_binds` already forbids two processes binding the same
-    /// DB path concurrently in normal operation).
-    pub pending_snapshots: Arc<Mutex<HashSet<String>>>,
-}
-
-impl AppState {
-    /// Open the DuckDB at `db_path`, apply the schema, and return shared state.
-    /// `bearer_token` must be non-empty. Admin endpoints are unmounted by
-    /// default; call [`AppState::with_admin`] with a non-empty token to enable
-    /// them.
-    pub fn open<P: AsRef<Path>>(db_path: P, bearer_token: String) -> Result<Self> {
-        validate_bearer_token("INGEST_BEARER_TOKEN", &bearer_token)?;
-        let path = db_path.as_ref().to_path_buf();
-        let parent = path.parent().unwrap_or_else(|| Path::new("."));
-        let snapshot_dir = parent.join("snapshots");
-        let extension_dir = parent.join("duckdb-extensions");
-        let db = db::open(&path, &extension_dir)?;
-        let read_store = ReadStore::build_initial(&db)?;
-        Ok(Self {
-            db,
-            bearer_token: Arc::new(bearer_token),
-            admin_bearer_token: None,
-            db_path: Arc::new(path),
-            cache: Arc::new(QueryCache::new()),
-            read_store: Arc::new(read_store),
-            snapshot_dir: Arc::new(snapshot_dir),
-            extension_dir: Arc::new(extension_dir),
-            pending_snapshots: Arc::new(Mutex::new(HashSet::new())),
-        })
-    }
-
-    /// Enable the `/api/admin/*` router, gated by `admin_bearer_token`.
-    /// Without this call, the admin router is not mounted at all.
-    pub fn with_admin(mut self, admin_bearer_token: String) -> Self {
-        if !admin_bearer_token.trim().is_empty() {
-            self.admin_bearer_token = Some(Arc::new(admin_bearer_token));
-        }
-        self
-    }
-
-    /// Override the directory `/api/admin/snapshot` writes per-table Vortex
-    /// snapshots into (`schema.sql` plus one `<table>.vortex` file per table).
-    /// Defaults to `<db_path parent>/snapshots`.
-    pub fn with_snapshot_dir(mut self, dir: PathBuf) -> Self {
-        self.snapshot_dir = Arc::new(dir);
-        self
-    }
-
-    /// Override the directory DuckDB installs extensions into and re-run
-    /// `SET GLOBAL extension_directory` on the root connection so the new
-    /// value propagates to every cloned connection. Fallible because it
-    /// touches the DB; the other builders are infallible because they only
-    /// shuffle `AppState` fields.
-    pub fn with_extension_dir(mut self, dir: PathBuf) -> Result<Self> {
-        self.db.set_extension_directory(&dir)?;
-        self.extension_dir = Arc::new(dir);
-        Ok(self)
-    }
-}
-
-fn validate_bearer_token(name: &str, token: &str) -> Result<()> {
-    ensure!(!token.trim().is_empty(), "{name} must not be empty");
-    Ok(())
-}
-
-/// Build the public router - `/api/ingest`, the read API, `/health`,
-/// and HTML routes. Does not include any `/api/admin/*` routes; those
-/// live on a separate listener built by [`admin_router`].
-pub fn public_router(state: AppState) -> Router {
-    let ingest_routes = Router::new()
-        .route("/api/ingest", post(ingest::handle))
-        .layer(DefaultBodyLimit::max(INGEST_BODY_LIMIT_BYTES))
-        .route_layer(axum::middleware::from_fn_with_state(
-            state.clone(),
-            require_bearer,
-        ));
-
-    let read_routes = Router::new()
-        .route("/api/groups", get(api::groups))
-        .route("/api/chart/{slug}", get(api::chart))
-        .route("/api/group/{slug}", get(api::group))
-        .route(
-            "/api/artifacts/{generation}/groups/{group_slug}/shards/{index}",
-            get(api::group_shard_artifact),
-        )
-        .route("/health", get(api::health));
-
-    Router::new()
-        .merge(ingest_routes)
-        .merge(read_routes)
-        .merge(html::router())
-        .layer(CompressionLayer::new())
-        .with_state(state)
-}
-
-/// Build the admin router when [`AppState::with_admin`] has been called;
-/// returns `None` otherwise so the caller skips binding the admin
-/// listener entirely.
-pub fn admin_router(state: AppState) -> Option<Router> {
-    state.admin_bearer_token.as_ref()?;
-    let admin_routes = Router::new()
-        .route("/api/admin/snapshot", post(admin::snapshot))
-        .route("/api/admin/sql", post(admin::sql))
-        .route_layer(axum::middleware::from_fn_with_state(
-            state.clone(),
-            admin::require_admin_bearer,
-        ));
-    Some(
-        admin_routes
-            .layer(CompressionLayer::new())
-            .with_state(state),
-    )
-}
-
-/// Merge the public and admin routers into a single router. Used by
-/// tests that don't care about the listener split; production runs the
-/// two routers on separate listeners via [`public_router`] +
-/// [`admin_router`].
-///
-/// Reuses [`public_router`] and [`admin_router`] so a route added to
-/// either of those flows into the test surface here too. Previously this
-/// re-spelled both router bodies inline, which silently drifted from
-/// production whenever someone touched only `public_router`.
-pub fn router(state: AppState) -> Router {
-    let public = public_router(state.clone());
-    match admin_router(state) {
-        Some(admin) => public.merge(admin),
-        None => public,
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use tempfile::TempDir;
-
-    use super::*;
-
-    #[test]
-    fn open_rejects_empty_ingest_token() {
-        let tmp = TempDir::new().unwrap();
-        let result = AppState::open(tmp.path().join("bench.duckdb"), String::new());
-        assert!(
-            result.is_err(),
-            "empty INGEST_BEARER_TOKEN should fail startup"
-        );
-    }
-
-    #[test]
-    fn empty_admin_token_leaves_admin_disabled() -> Result<()> {
-        let tmp = TempDir::new()?;
-        let state = AppState::open(tmp.path().join("bench.duckdb"), "ingest-token".to_string())?
-            .with_admin(String::new());
-        assert!(
-            state.admin_bearer_token.is_none(),
-            "empty ADMIN_BEARER_TOKEN should not mount admin routes"
-        );
-        Ok(())
-    }
-}
diff --git a/benchmarks-website/server/src/auth.rs b/benchmarks-website/server/src/auth.rs
deleted file mode 100644
index f935de59b73..00000000000
--- a/benchmarks-website/server/src/auth.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Bearer-token authentication for `/api/ingest`.
-//!
-//! The token is read from `INGEST_BEARER_TOKEN` at startup and compared with
-//! constant-time equality.
-
-use axum::extract::Request;
-use axum::extract::State;
-use axum::http::header::AUTHORIZATION;
-use axum::middleware::Next;
-use axum::response::Response;
-use subtle::ConstantTimeEq;
-
-use crate::app::AppState;
-use crate::error::IngestError;
-
-/// Axum middleware that enforces a `Bearer <token>` header on the route.
-pub async fn require_bearer(
-    State(state): State<AppState>,
-    req: Request,
-    next: Next,
-) -> Result<Response, IngestError> {
-    let header = req
-        .headers()
-        .get(AUTHORIZATION)
-        .ok_or(IngestError::Unauthorized)?
-        .to_str()
-        .map_err(|_| IngestError::Unauthorized)?;
-
-    let presented = header
-        .strip_prefix("Bearer ")
-        .ok_or(IngestError::Unauthorized)?
-        .as_bytes();
-    let expected = state.bearer_token.as_bytes();
-
-    if presented.ct_eq(expected).into() {
-        Ok(next.run(req).await)
-    } else {
-        Err(IngestError::Unauthorized)
-    }
-}
diff --git a/benchmarks-website/server/src/db.rs b/benchmarks-website/server/src/db.rs
deleted file mode 100644
index 6bc44543c4e..00000000000
--- a/benchmarks-website/server/src/db.rs
+++ /dev/null
@@ -1,316 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! DuckDB connection management plus the deterministic `measurement_id` hash.
-//!
-//! The server keeps one root [`duckdb::Connection`] and clones a fresh
-//! connection from it for each blocking DB task. All DB work runs inside
-//! `spawn_blocking` so the Tokio runtime is never blocked on synchronous
-//! DuckDB calls.
-//!
-//! `measurement_id` is a server-internal xxhash64 over `commit_sha` plus
-//! each table's dimensional tuple. Including `commit_sha` makes every
-//! (commit, dim) pair a distinct row, which is what the chart pages render
-//! as a time series; re-ingest of the same pair is the upsert case. The
-//! hash never crosses a process boundary, so the exact byte layout below
-//! is private to this server.
-
-use std::hash::Hasher as _;
-use std::path::Path;
-use std::sync::Arc;
-
-use anyhow::Context as _;
-use anyhow::Result;
-use duckdb::Connection;
-use parking_lot::Mutex;
-use tokio::sync::OwnedSemaphorePermit;
-use tokio::sync::Semaphore;
-use twox_hash::XxHash64;
-
-use crate::family;
-use crate::records::CompressionSize;
-use crate::records::CompressionTime;
-use crate::records::QueryMeasurement;
-use crate::records::RandomAccessTime;
-use crate::records::VectorSearchRun;
-use crate::schema::COMMITS_DDL;
-
-const READ_CONCURRENCY_LIMIT: usize = 4;
-
-/// Shared DuckDB handle. Cloning the handle is cheap; each DB task clones a
-/// task-local [`Connection`] before doing work.
-#[derive(Clone)]
-pub struct DbHandle {
-    root: Arc<Mutex<Connection>>,
-    read_permits: Arc<Semaphore>,
-}
-
-impl DbHandle {
-    fn new(root: Connection) -> Self {
-        Self {
-            root: Arc::new(Mutex::new(root)),
-            read_permits: Arc::new(Semaphore::new(READ_CONCURRENCY_LIMIT)),
-        }
-    }
-
-    pub(crate) fn connection(&self) -> Result<Connection> {
-        let root = self.root.lock();
-        root.try_clone().context("cloning DuckDB connection")
-    }
-}
-
-/// Open the DuckDB file at `path` (creating it if absent), point its
-/// extension installer at `extension_dir`, and apply the schema DDL.
-/// Returns a handle ready to be cloned into the Axum state.
-///
-/// `extension_dir` is created if missing. Pointing DuckDB at a directory
-/// we control (instead of its default `~/.duckdb/extensions/...`) is what
-/// lets the snapshot path's `INSTALL vortex` succeed under systemd's
-/// `ProtectHome=read-only`.
-pub fn open<P: AsRef<Path>>(path: P, extension_dir: &Path) -> Result<DbHandle> {
-    std::fs::create_dir_all(extension_dir)
-        .with_context(|| format!("creating DuckDB extension dir {}", extension_dir.display()))?;
-    let conn = Connection::open(path.as_ref())
-        .with_context(|| format!("opening DuckDB at {}", path.as_ref().display()))?;
-    apply_extension_directory(&conn, extension_dir)?;
-    conn.execute_batch(COMMITS_DDL)
-        .context("applying commits dim DDL")?;
-    for fam in family::FAMILIES {
-        conn.execute_batch(fam.schema_ddl)
-            .with_context(|| format!("applying {} DDL", fam.table_name))?;
-    }
-    Ok(DbHandle::new(conn))
-}
-
-impl DbHandle {
-    /// Re-point DuckDB's extension installer at `dir` on the root connection.
-    /// `SET GLOBAL` propagates to every connection cloned from it, so a
-    /// later override at startup picks up before any handler runs.
-    pub(crate) fn set_extension_directory(&self, dir: &Path) -> Result<()> {
-        std::fs::create_dir_all(dir)
-            .with_context(|| format!("creating DuckDB extension dir {}", dir.display()))?;
-        let root = self.root.lock();
-        apply_extension_directory(&root, dir)
-    }
-}
-
-fn apply_extension_directory(conn: &Connection, dir: &Path) -> Result<()> {
-    let dir_str = dir
-        .to_str()
-        .ok_or_else(|| anyhow::anyhow!("extension dir is not UTF-8: {}", dir.display()))?;
-    let sql = format!(
-        "SET GLOBAL extension_directory = {}",
-        sql_string_literal(dir_str)
-    );
-    conn.execute_batch(&sql)
-        .with_context(|| format!("SET GLOBAL extension_directory = {dir_str:?}"))
-}
-
-/// Quote `value` as a SQL string literal, escaping embedded single quotes.
-/// Shared between the schema-time `SET GLOBAL` and the per-snapshot
-/// `COPY ... TO '<path>' (FORMAT vortex)` so neither has to roll its own.
-pub(crate) fn sql_string_literal(value: &str) -> String {
-    format!("'{}'", value.replace('\'', "''"))
-}
-
-/// Run a synchronous DB operation on the blocking pool using a task-local
-/// DuckDB connection cloned from the shared database handle.
-pub async fn run_blocking<F, T>(handle: &DbHandle, f: F) -> Result<T>
-where
-    F: FnOnce(&mut Connection) -> Result<T> + Send + 'static,
-    T: Send + 'static,
-{
-    run_blocking_inner(handle, None, f).await
-}
-
-/// Run a read-side DB operation on the blocking pool, capped by the read
-/// concurrency semaphore so a hydration burst cannot flood DuckDB with
-/// unbounded concurrent scans.
-pub async fn run_read_blocking<F, T>(handle: &DbHandle, f: F) -> Result<T>
-where
-    F: FnOnce(&mut Connection) -> Result<T> + Send + 'static,
-    T: Send + 'static,
-{
-    let permit = handle
-        .read_permits
-        .clone()
-        .acquire_owned()
-        .await
-        .context("read semaphore closed")?;
-    run_blocking_inner(handle, Some(permit), f).await
-}
-
-async fn run_blocking_inner<F, T>(
-    handle: &DbHandle,
-    permit: Option<OwnedSemaphorePermit>,
-    f: F,
-) -> Result<T>
-where
-    F: FnOnce(&mut Connection) -> Result<T> + Send + 'static,
-    T: Send + 'static,
-{
-    let handle = handle.clone();
-    tokio::task::spawn_blocking(move || {
-        let _permit = permit;
-        let mut conn = handle.connection()?;
-        f(&mut conn)
-    })
-    .await
-    .context("DB task panicked")?
-}
-
-/// Finalize the hash and bit-cast to `i64` because DuckDB's `BIGINT` is
-/// signed.
-fn finish(hasher: XxHash64) -> i64 {
-    hasher.finish() as i64
-}
-
-fn write_str(hasher: &mut XxHash64, s: &str) {
-    hasher.write_u64(s.len() as u64);
-    hasher.write(s.as_bytes());
-}
-
-fn write_opt_str(hasher: &mut XxHash64, s: Option<&str>) {
-    match s {
-        Some(s) => {
-            hasher.write_u8(1);
-            write_str(hasher, s);
-        }
-        None => hasher.write_u8(0),
-    }
-}
-
-fn write_i32(hasher: &mut XxHash64, v: i32) {
-    hasher.write_i32(v);
-}
-
-fn write_f64(hasher: &mut XxHash64, v: f64) {
-    hasher.write_u64(v.to_bits());
-}
-
-/// Initialize a hasher seeded with a per-table tag so two fact tables that
-/// happen to share the same dim values still produce distinct
-/// `measurement_id`s.
-fn hasher_for(tag: &'static str) -> XxHash64 {
-    let mut h = XxHash64::with_seed(0);
-    h.write(tag.as_bytes());
-    h.write_u8(0);
-    h
-}
-
-/// Hash for `query_measurements` rows. Includes `commit_sha` so each
-/// (commit, dim tuple) pair gets a distinct row; re-emission of the same
-/// pair is the upsert case.
-pub fn measurement_id_query(r: &QueryMeasurement) -> i64 {
-    let mut h = hasher_for("query_measurements");
-    write_str(&mut h, &r.commit_sha);
-    write_str(&mut h, &r.dataset);
-    write_opt_str(&mut h, r.dataset_variant.as_deref());
-    write_opt_str(&mut h, r.scale_factor.as_deref());
-    write_i32(&mut h, r.query_idx);
-    write_str(&mut h, &r.storage);
-    write_str(&mut h, &r.engine);
-    write_str(&mut h, &r.format);
-    finish(h)
-}
-
-/// Hash for `compression_times` rows.
-pub fn measurement_id_compression_time(r: &CompressionTime) -> i64 {
-    let mut h = hasher_for("compression_times");
-    write_str(&mut h, &r.commit_sha);
-    write_str(&mut h, &r.dataset);
-    write_opt_str(&mut h, r.dataset_variant.as_deref());
-    write_str(&mut h, &r.format);
-    write_str(&mut h, &r.op);
-    finish(h)
-}
-
-/// Hash for `compression_sizes` rows.
-pub fn measurement_id_compression_size(r: &CompressionSize) -> i64 {
-    let mut h = hasher_for("compression_sizes");
-    write_str(&mut h, &r.commit_sha);
-    write_str(&mut h, &r.dataset);
-    write_opt_str(&mut h, r.dataset_variant.as_deref());
-    write_str(&mut h, &r.format);
-    finish(h)
-}
-
-/// Hash for `random_access_times` rows.
-pub fn measurement_id_random_access(r: &RandomAccessTime) -> i64 {
-    let mut h = hasher_for("random_access_times");
-    write_str(&mut h, &r.commit_sha);
-    write_str(&mut h, &r.dataset);
-    write_str(&mut h, &r.format);
-    finish(h)
-}
-
-/// Hash for `vector_search_runs` rows. `iterations` is intentionally not
-/// part of the dim tuple - it is a side count, not a dimension.
-pub fn measurement_id_vector_search(r: &VectorSearchRun) -> i64 {
-    let mut h = hasher_for("vector_search_runs");
-    write_str(&mut h, &r.commit_sha);
-    write_str(&mut h, &r.dataset);
-    write_str(&mut h, &r.layout);
-    write_str(&mut h, &r.flavor);
-    write_f64(&mut h, r.threshold);
-    finish(h)
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::Arc;
-    use std::sync::atomic::AtomicUsize;
-    use std::sync::atomic::Ordering;
-    use std::time::Duration;
-
-    use anyhow::Result;
-    use tempfile::TempDir;
-
-    use super::*;
-
-    fn record_max(max_active: &AtomicUsize, value: usize) {
-        let mut current = max_active.load(Ordering::SeqCst);
-        while value > current {
-            match max_active.compare_exchange(current, value, Ordering::SeqCst, Ordering::SeqCst) {
-                Ok(_) => break,
-                Err(next) => current = next,
-            }
-        }
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-    async fn run_read_blocking_limits_concurrent_db_tasks() -> Result<()> {
-        let tmp = TempDir::new()?;
-        let extension_dir = tmp.path().join("duckdb-extensions");
-        let handle = open(tmp.path().join("bench.duckdb"), &extension_dir)?;
-        let active = Arc::new(AtomicUsize::new(0));
-        let max_active = Arc::new(AtomicUsize::new(0));
-        let mut tasks = Vec::new();
-
-        for _ in 0..12 {
-            let active = Arc::clone(&active);
-            let max_active = Arc::clone(&max_active);
-            let handle = handle.clone();
-            tasks.push(tokio::spawn(async move {
-                run_read_blocking(&handle, move |_conn| {
-                    let now = active.fetch_add(1, Ordering::SeqCst) + 1;
-                    record_max(&max_active, now);
-                    std::thread::sleep(Duration::from_millis(25));
-                    active.fetch_sub(1, Ordering::SeqCst);
-                    Ok(())
-                })
-                .await
-            }));
-        }
-
-        for task in tasks {
-            task.await??;
-        }
-
-        assert!(
-            max_active.load(Ordering::SeqCst) <= 4,
-            "read DB tasks should be capped at four concurrent workers"
-        );
-        Ok(())
-    }
-}
diff --git a/benchmarks-website/server/src/error.rs b/benchmarks-website/server/src/error.rs
deleted file mode 100644
index ffaee55a388..00000000000
--- a/benchmarks-website/server/src/error.rs
+++ /dev/null
@@ -1,118 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Error types for the bench server.
-//!
-//! [`IngestError`] models the HTTP matrix documented on
-//! [`crate::ingest`] for the `POST /api/ingest` route. [`ApiError`] is
-//! the catch-all for read routes.
-
-use axum::Json;
-use axum::http::StatusCode;
-use axum::response::IntoResponse;
-use axum::response::Response;
-use serde_json::json;
-use thiserror::Error;
-
-/// Errors surfaced by `POST /api/ingest`. Each variant maps to a specific
-/// HTTP status per the contract.
-#[derive(Debug, Error)]
-pub enum IngestError {
-    /// 400 - the request body wasn't valid JSON or didn't match the envelope
-    /// schema (including unknown `kind` values and unknown fields).
-    #[error("malformed request body: {0}")]
-    Malformed(String),
-
-    /// 400 - a per-record validation rule failed. Carries the offending
-    /// record's index in `records` so emitters can pinpoint the problem.
-    #[error("record at index {index} failed validation: {message}")]
-    Record { index: usize, message: String },
-
-    /// 401 - the bearer token was missing or did not match.
-    #[error("missing or invalid bearer token")]
-    Unauthorized,
-
-    /// 409 - the envelope's `schema_version` is newer than this server expects.
-    #[error("schema version {got} is newer than server's {expected}")]
-    SchemaVersionTooNew { expected: i32, got: i32 },
-
-    /// 500 - any other error. Avoid leaking internals to clients.
-    #[error("internal server error")]
-    Internal(#[from] anyhow::Error),
-}
-
-impl IngestError {
-    fn status(&self) -> StatusCode {
-        match self {
-            Self::Malformed(_) | Self::Record { .. } => StatusCode::BAD_REQUEST,
-            Self::Unauthorized => StatusCode::UNAUTHORIZED,
-            Self::SchemaVersionTooNew { .. } => StatusCode::CONFLICT,
-            Self::Internal(_) => StatusCode::INTERNAL_SERVER_ERROR,
-        }
-    }
-}
-
-impl IntoResponse for IngestError {
-    fn into_response(self) -> Response {
-        let status = self.status();
-        let body = match &self {
-            Self::Malformed(msg) => json!({ "error": "malformed", "message": msg }),
-            Self::Record { index, message } => json!({
-                "error": "record",
-                "record_index": index,
-                "message": message,
-            }),
-            Self::Unauthorized => json!({ "error": "unauthorized" }),
-            Self::SchemaVersionTooNew { expected, got } => json!({
-                "error": "schema_version_too_new",
-                "expected": expected,
-                "got": got,
-            }),
-            Self::Internal(err) => {
-                tracing::error!(error = ?err, "ingest internal error");
-                json!({ "error": "internal" })
-            }
-        };
-        (status, Json(body)).into_response()
-    }
-}
-
-/// Errors surfaced by the read API and `/health`.
-#[derive(Debug, Error)]
-pub enum ApiError {
-    /// 404 - the slug supplied to `/api/chart/:slug` couldn't be parsed
-    /// or matched no rows.
-    #[error("not found: {0}")]
-    NotFound(String),
-
-    /// 400 - the slug or query parameters were syntactically invalid.
-    #[error("bad request: {0}")]
-    BadRequest(String),
-
-    /// 500 - any other error.
-    #[error("internal server error")]
-    Internal(#[from] anyhow::Error),
-}
-
-impl IntoResponse for ApiError {
-    fn into_response(self) -> Response {
-        let (status, body) = match &self {
-            Self::NotFound(msg) => (
-                StatusCode::NOT_FOUND,
-                json!({ "error": "not_found", "message": msg }),
-            ),
-            Self::BadRequest(msg) => (
-                StatusCode::BAD_REQUEST,
-                json!({ "error": "bad_request", "message": msg }),
-            ),
-            Self::Internal(err) => {
-                tracing::error!(error = ?err, "api internal error");
-                (
-                    StatusCode::INTERNAL_SERVER_ERROR,
-                    json!({ "error": "internal" }),
-                )
-            }
-        };
-        (status, Json(body)).into_response()
-    }
-}
diff --git a/benchmarks-website/server/src/family.rs b/benchmarks-website/server/src/family.rs
deleted file mode 100644
index 125bcec946b..00000000000
--- a/benchmarks-website/server/src/family.rs
+++ /dev/null
@@ -1,545 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Per-fact-table registry.
-//!
-//! Each of the five fact tables (`query_measurements`, `compression_times`,
-//! `compression_sizes`, `random_access_times`, `vector_search_runs`) is a
-//! [`Family`]. Every Family declaration ties together the table name, the
-//! chart and group slug prefixes, the `measurement_id_*` hash function, the
-//! `apply_record` branch, the read-API chart and group collectors, and the
-//! row-count query. Adding a sixth fact table is one new const [`Family`]
-//! plus one entry in [`FAMILIES`]; the compiler enforces every required
-//! hook is populated.
-//!
-//! See [`crate::schema`] for the DuckDB schema this registry is paired
-//! with, [`crate::records::Record`] for the wire shape each Family
-//! deserializes, and [`crate::slug`] for the slug variants each Family
-//! claims (via [`Family::chart_slug_prefix`] / [`Family::group_slug_prefix`]).
-//!
-//! # The "spine" contract
-//!
-//! Every call site that varies per-fact-table dispatches through this
-//! registry instead of hand-listing the families:
-//!
-//! - `crate::db::open` and `crate::ingest::apply_record` iterate
-//!   [`FAMILIES`] for DDL apply and per-record dispatch.
-//! - `crate::api::charts::chart_payload` and
-//!   `crate::api::groups::collect_groups` dispatch through
-//!   [`family_for_chart_key`] / per-family `collect_groups`.
-//! - `crate::api::collect_health` iterates [`FAMILIES`] for `/health`'s
-//!   `row_counts` map. The wire shape uses a `BTreeMap` so a new family
-//!   appears in the response automatically; consumers index by table
-//!   name (`row_counts["query_measurements"]`) just as before.
-//! - `crate::slug::ChartKey::prefix` and `GroupKey::prefix` consult the
-//!   registry rather than maintaining a parallel `PREFIX_*` const table.
-//! - `crate::schema::TABLES` is derived from this registry at first use
-//!   so the snapshot endpoint, the restore docs, and any future caller
-//!   that needs the table-name set see the registry as the single source
-//!   of truth.
-//!
-//! Per-family adapter functions in this file still trampoline into free
-//! functions in [`mod@crate::api::charts`], [`mod@crate::api::groups`],
-//! [`crate::db`], and [`crate::ingest`]. Inlining those bodies into the
-//! adapters is mechanical and tracked as future cleanup; it does not
-//! affect the spine contract above.
-
-use anyhow::Result;
-use duckdb::Connection;
-use duckdb::Transaction;
-
-use crate::api::ChartResponse;
-use crate::api::CommitWindow;
-use crate::api::Group;
-use crate::api::charts;
-use crate::api::groups;
-use crate::db;
-use crate::ingest;
-use crate::ingest::RecordError;
-use crate::records::Record;
-use crate::slug::ChartKey;
-use crate::slug::GroupKey;
-
-/// One fact-table family.
-///
-/// Function-pointer fields (not closures) let the struct live in `const`
-/// position so the registry is statically allocated. Adding a new family
-/// means declaring one `const <NAME>_FAMILY: Family = Family { ... }` and
-/// appending it to [`FAMILIES`].
-pub struct Family {
-    /// DuckDB table name. The `hasher_for(<table_name>)` seed in
-    /// [`crate::db`] uses this string verbatim, so two families with
-    /// otherwise-equal dim tuples still hash to distinct
-    /// `measurement_id`s.
-    pub table_name: &'static str,
-
-    /// Slug prefix for individual charts in this family (e.g. `qm` for
-    /// `query_measurements`). Paired with the JSON-encoded
-    /// [`ChartKey`] variant - see [`crate::slug`].
-    pub chart_slug_prefix: &'static str,
-
-    /// Slug prefix for groups of this family's charts (e.g. `qmg`).
-    pub group_slug_prefix: &'static str,
-
-    /// `CREATE TABLE IF NOT EXISTS <table_name> (...)` for this family.
-    /// [`crate::db::open`] runs the [`crate::schema::COMMITS_DDL`] dim
-    /// table first, then iterates [`FAMILIES`] and applies this DDL for
-    /// every family. Adding a sixth fact table means one new const DDL
-    /// in [`crate::schema`] plus pointing this field at it; no new edit
-    /// in `db::open()`.
-    pub schema_ddl: &'static str,
-
-    /// Compute the deterministic `measurement_id` for a record of this
-    /// family. The caller is responsible for ensuring `record` is this
-    /// family's variant (see [`family_for_record`]); calling with a
-    /// foreign variant panics.
-    pub measurement_id: fn(&Record) -> i64,
-
-    /// Insert one record into this family's fact table inside an open
-    /// transaction. Returns `true` if the row was an upsert (existing
-    /// `measurement_id`) and `false` if it was a fresh insert. The
-    /// caller is responsible for ensuring `record` is this family's
-    /// variant; calling with a foreign variant panics.
-    ///
-    /// `pub(crate)` because [`RecordError`] is itself `pub(crate)` (it
-    /// is intra-server error plumbing, not part of the public API).
-    pub(crate) apply_record: fn(&Transaction<'_>, &Record) -> Result<bool, RecordError>,
-
-    /// Collect this family's chart payload for the supplied [`ChartKey`].
-    /// Returns `Ok(None)` if no rows exist for the key; the caller maps
-    /// that to a 404. The caller is responsible for ensuring `key` is
-    /// this family's variant (see [`family_for_chart_key`]); calling
-    /// with a foreign variant panics.
-    pub collect_chart_for_key:
-        fn(&Connection, &ChartKey, &CommitWindow) -> Result<Option<ChartResponse>>,
-
-    /// Discovery pass: enumerate every group of this family present in
-    /// the DB. The returned `Vec` may be empty if no rows exist. The
-    /// three singleton-group families (compression-times, compression-
-    /// sizes, random-access) return a zero-or-one-element `Vec` here.
-    pub collect_groups: fn(&Connection) -> Result<Vec<Group>>,
-
-    /// Row count of this family's fact table; used by `/health` to
-    /// surface per-table counts without spelling out the table names in
-    /// the handler.
-    pub row_count: fn(&Connection) -> Result<i64>,
-}
-
-/// All five fact-table families, in the order [`crate::schema::TABLES`]
-/// applies their DDL. Adding a family appends one entry here.
-pub const FAMILIES: &[&Family] = &[
-    &QUERY_MEASUREMENTS,
-    &COMPRESSION_TIMES,
-    &COMPRESSION_SIZES,
-    &RANDOM_ACCESS_TIMES,
-    &VECTOR_SEARCH_RUNS,
-];
-
-/// Look up the family that owns `record`'s variant.
-pub fn family_for_record(record: &Record) -> &'static Family {
-    match record {
-        Record::QueryMeasurement(_) => &QUERY_MEASUREMENTS,
-        Record::CompressionTime(_) => &COMPRESSION_TIMES,
-        Record::CompressionSize(_) => &COMPRESSION_SIZES,
-        Record::RandomAccessTime(_) => &RANDOM_ACCESS_TIMES,
-        Record::VectorSearchRun(_) => &VECTOR_SEARCH_RUNS,
-    }
-}
-
-/// Look up the family that owns `key`'s variant.
-pub fn family_for_chart_key(key: &ChartKey) -> &'static Family {
-    match key {
-        ChartKey::QueryMeasurement { .. } => &QUERY_MEASUREMENTS,
-        ChartKey::CompressionTime { .. } => &COMPRESSION_TIMES,
-        ChartKey::CompressionSize { .. } => &COMPRESSION_SIZES,
-        ChartKey::RandomAccess { .. } => &RANDOM_ACCESS_TIMES,
-        ChartKey::VectorSearch { .. } => &VECTOR_SEARCH_RUNS,
-    }
-}
-
-/// Look up the family that owns `key`'s variant.
-pub fn family_for_group_key(key: &GroupKey) -> &'static Family {
-    match key {
-        GroupKey::QueryGroup { .. } => &QUERY_MEASUREMENTS,
-        GroupKey::CompressionTimeGroup => &COMPRESSION_TIMES,
-        GroupKey::CompressionSizeGroup => &COMPRESSION_SIZES,
-        GroupKey::RandomAccessGroup => &RANDOM_ACCESS_TIMES,
-        GroupKey::VectorSearchGroup { .. } => &VECTOR_SEARCH_RUNS,
-    }
-}
-
-// -----------------------------------------------------------------------
-// Per-family declarations.
-//
-// Each Family's function-pointer fields point at small adapter functions
-// that pattern-match the outer Record / ChartKey enums against the
-// family's variant and delegate to the existing free functions in
-// `crate::api::charts`, `crate::api::groups`, `crate::db`, and
-// `crate::ingest`. Inlining those bodies into the adapters is mechanical
-// future cleanup; the registry above is already the spine for the call
-// sites that vary per-family.
-// -----------------------------------------------------------------------
-
-/// Family for `query_measurements`.
-pub const QUERY_MEASUREMENTS: Family = Family {
-    table_name: "query_measurements",
-    chart_slug_prefix: "qm",
-    group_slug_prefix: "qmg",
-    schema_ddl: crate::schema::QUERY_MEASUREMENTS_DDL,
-    measurement_id: query_measurement_id,
-    apply_record: query_apply_record,
-    collect_chart_for_key: query_collect_chart,
-    collect_groups: groups::collect_query_groups,
-    row_count: query_row_count,
-};
-
-/// Family for `compression_times`.
-pub const COMPRESSION_TIMES: Family = Family {
-    table_name: "compression_times",
-    chart_slug_prefix: "ct",
-    group_slug_prefix: "ctg",
-    schema_ddl: crate::schema::COMPRESSION_TIMES_DDL,
-    measurement_id: compression_time_measurement_id,
-    apply_record: compression_time_apply_record,
-    collect_chart_for_key: compression_time_collect_chart,
-    collect_groups: compression_time_collect_groups,
-    row_count: compression_time_row_count,
-};
-
-/// Family for `compression_sizes`.
-pub const COMPRESSION_SIZES: Family = Family {
-    table_name: "compression_sizes",
-    chart_slug_prefix: "cs",
-    group_slug_prefix: "csg",
-    schema_ddl: crate::schema::COMPRESSION_SIZES_DDL,
-    measurement_id: compression_size_measurement_id,
-    apply_record: compression_size_apply_record,
-    collect_chart_for_key: compression_size_collect_chart,
-    collect_groups: compression_size_collect_groups,
-    row_count: compression_size_row_count,
-};
-
-/// Family for `random_access_times`.
-pub const RANDOM_ACCESS_TIMES: Family = Family {
-    table_name: "random_access_times",
-    chart_slug_prefix: "rat",
-    group_slug_prefix: "rag",
-    schema_ddl: crate::schema::RANDOM_ACCESS_TIMES_DDL,
-    measurement_id: random_access_measurement_id,
-    apply_record: random_access_apply_record,
-    collect_chart_for_key: random_access_collect_chart,
-    collect_groups: random_access_collect_groups,
-    row_count: random_access_row_count,
-};
-
-/// Family for `vector_search_runs`.
-pub const VECTOR_SEARCH_RUNS: Family = Family {
-    table_name: "vector_search_runs",
-    chart_slug_prefix: "vsr",
-    group_slug_prefix: "vsg",
-    schema_ddl: crate::schema::VECTOR_SEARCH_RUNS_DDL,
-    measurement_id: vector_search_measurement_id,
-    apply_record: vector_search_apply_record,
-    collect_chart_for_key: vector_search_collect_chart,
-    collect_groups: groups::collect_vector_search_groups,
-    row_count: vector_search_row_count,
-};
-
-// -----------------------------------------------------------------------
-// Per-family adapter functions. Each is a thin pattern-match-and-delegate
-// wrapper over the existing free function with the matching name in
-// `crate::api::charts`, `crate::api::groups`, `crate::db`, or
-// `crate::ingest`.
-// -----------------------------------------------------------------------
-
-fn query_measurement_id(record: &Record) -> i64 {
-    let Record::QueryMeasurement(r) = record else {
-        panic!("query_measurement_id called with non-query record");
-    };
-    db::measurement_id_query(r)
-}
-
-fn query_apply_record(tx: &Transaction<'_>, record: &Record) -> Result<bool, RecordError> {
-    let Record::QueryMeasurement(r) = record else {
-        panic!("query_apply_record called with non-query record");
-    };
-    ingest::insert_query_measurement(tx, r)
-}
-
-fn query_collect_chart(
-    conn: &Connection,
-    key: &ChartKey,
-    window: &CommitWindow,
-) -> Result<Option<ChartResponse>> {
-    let ChartKey::QueryMeasurement {
-        dataset,
-        dataset_variant,
-        scale_factor,
-        storage,
-        query_idx,
-    } = key
-    else {
-        panic!("query_collect_chart called with non-query key");
-    };
-    charts::collect_query_chart(
-        conn,
-        dataset,
-        dataset_variant,
-        scale_factor,
-        storage,
-        *query_idx,
-        window,
-    )
-}
-
-fn query_row_count(conn: &Connection) -> Result<i64> {
-    count_rows(conn, "query_measurements")
-}
-
-fn compression_time_measurement_id(record: &Record) -> i64 {
-    let Record::CompressionTime(r) = record else {
-        panic!("compression_time_measurement_id called with non-compression-time record");
-    };
-    db::measurement_id_compression_time(r)
-}
-
-fn compression_time_apply_record(
-    tx: &Transaction<'_>,
-    record: &Record,
-) -> Result<bool, RecordError> {
-    let Record::CompressionTime(r) = record else {
-        panic!("compression_time_apply_record called with non-compression-time record");
-    };
-    ingest::insert_compression_time(tx, r)
-}
-
-fn compression_time_collect_chart(
-    conn: &Connection,
-    key: &ChartKey,
-    window: &CommitWindow,
-) -> Result<Option<ChartResponse>> {
-    let ChartKey::CompressionTime {
-        dataset,
-        dataset_variant,
-    } = key
-    else {
-        panic!("compression_time_collect_chart called with non-compression-time key");
-    };
-    charts::collect_compression_time_chart(conn, dataset, dataset_variant, window)
-}
-
-fn compression_time_collect_groups(conn: &Connection) -> Result<Vec<Group>> {
-    Ok(groups::collect_compression_time_group(conn)?
-        .into_iter()
-        .collect())
-}
-
-fn compression_time_row_count(conn: &Connection) -> Result<i64> {
-    count_rows(conn, "compression_times")
-}
-
-fn compression_size_measurement_id(record: &Record) -> i64 {
-    let Record::CompressionSize(r) = record else {
-        panic!("compression_size_measurement_id called with non-compression-size record");
-    };
-    db::measurement_id_compression_size(r)
-}
-
-fn compression_size_apply_record(
-    tx: &Transaction<'_>,
-    record: &Record,
-) -> Result<bool, RecordError> {
-    let Record::CompressionSize(r) = record else {
-        panic!("compression_size_apply_record called with non-compression-size record");
-    };
-    ingest::insert_compression_size(tx, r)
-}
-
-fn compression_size_collect_chart(
-    conn: &Connection,
-    key: &ChartKey,
-    window: &CommitWindow,
-) -> Result<Option<ChartResponse>> {
-    let ChartKey::CompressionSize {
-        dataset,
-        dataset_variant,
-    } = key
-    else {
-        panic!("compression_size_collect_chart called with non-compression-size key");
-    };
-    charts::collect_compression_size_chart(conn, dataset, dataset_variant, window)
-}
-
-fn compression_size_collect_groups(conn: &Connection) -> Result<Vec<Group>> {
-    Ok(groups::collect_compression_size_group(conn)?
-        .into_iter()
-        .collect())
-}
-
-fn compression_size_row_count(conn: &Connection) -> Result<i64> {
-    count_rows(conn, "compression_sizes")
-}
-
-fn random_access_measurement_id(record: &Record) -> i64 {
-    let Record::RandomAccessTime(r) = record else {
-        panic!("random_access_measurement_id called with non-random-access record");
-    };
-    db::measurement_id_random_access(r)
-}
-
-fn random_access_apply_record(tx: &Transaction<'_>, record: &Record) -> Result<bool, RecordError> {
-    let Record::RandomAccessTime(r) = record else {
-        panic!("random_access_apply_record called with non-random-access record");
-    };
-    ingest::insert_random_access(tx, r)
-}
-
-fn random_access_collect_chart(
-    conn: &Connection,
-    key: &ChartKey,
-    window: &CommitWindow,
-) -> Result<Option<ChartResponse>> {
-    let ChartKey::RandomAccess { dataset } = key else {
-        panic!("random_access_collect_chart called with non-random-access key");
-    };
-    charts::collect_random_access_chart(conn, dataset, window)
-}
-
-fn random_access_collect_groups(conn: &Connection) -> Result<Vec<Group>> {
-    Ok(groups::collect_random_access_group(conn)?
-        .into_iter()
-        .collect())
-}
-
-fn random_access_row_count(conn: &Connection) -> Result<i64> {
-    count_rows(conn, "random_access_times")
-}
-
-fn vector_search_measurement_id(record: &Record) -> i64 {
-    let Record::VectorSearchRun(r) = record else {
-        panic!("vector_search_measurement_id called with non-vector-search record");
-    };
-    db::measurement_id_vector_search(r)
-}
-
-fn vector_search_apply_record(tx: &Transaction<'_>, record: &Record) -> Result<bool, RecordError> {
-    let Record::VectorSearchRun(r) = record else {
-        panic!("vector_search_apply_record called with non-vector-search record");
-    };
-    ingest::insert_vector_search(tx, r)
-}
-
-fn vector_search_collect_chart(
-    conn: &Connection,
-    key: &ChartKey,
-    window: &CommitWindow,
-) -> Result<Option<ChartResponse>> {
-    let ChartKey::VectorSearch {
-        dataset,
-        layout,
-        threshold,
-    } = key
-    else {
-        panic!("vector_search_collect_chart called with non-vector-search key");
-    };
-    charts::collect_vector_search_chart(conn, dataset, layout, *threshold, window)
-}
-
-fn vector_search_row_count(conn: &Connection) -> Result<i64> {
-    count_rows(conn, "vector_search_runs")
-}
-
-/// `SELECT COUNT(*) FROM <table>`. The table name comes from a const in a
-/// closed enum of literals above, never user input.
-fn count_rows(conn: &Connection, table: &'static str) -> Result<i64> {
-    let sql = format!("SELECT COUNT(*) FROM {table}");
-    let n: i64 = conn.query_row(&sql, [], |row| row.get(0))?;
-    Ok(n)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// `schema::TABLES` is derived from `FAMILIES` (see [`crate::schema`]),
-    /// so the order MUST be `commits` followed by every family in
-    /// declaration order. This test pins the derivation rule explicitly
-    /// in case someone replaces `TABLES` with a hand-written list again.
-    #[test]
-    fn schema_tables_derived_from_families() {
-        let mut expected: Vec<&'static str> = Vec::with_capacity(1 + FAMILIES.len());
-        expected.push("commits");
-        expected.extend(FAMILIES.iter().map(|f| f.table_name));
-        let actual: Vec<&'static str> = crate::schema::TABLES.iter().copied().collect();
-        assert_eq!(
-            actual, expected,
-            "schema::TABLES must be derived from FAMILIES (commits + each family's table_name)"
-        );
-    }
-
-    /// Slug prefixes are how the client and migrate path distinguish
-    /// families. They must be distinct.
-    #[test]
-    fn slug_prefixes_are_distinct() {
-        let chart_prefixes: Vec<&'static str> =
-            FAMILIES.iter().map(|f| f.chart_slug_prefix).collect();
-        let group_prefixes: Vec<&'static str> =
-            FAMILIES.iter().map(|f| f.group_slug_prefix).collect();
-        let mut sorted = chart_prefixes.clone();
-        sorted.sort_unstable();
-        sorted.dedup();
-        assert_eq!(
-            sorted.len(),
-            chart_prefixes.len(),
-            "chart prefixes distinct"
-        );
-        let mut sorted = group_prefixes.clone();
-        sorted.sort_unstable();
-        sorted.dedup();
-        assert_eq!(
-            sorted.len(),
-            group_prefixes.len(),
-            "group prefixes distinct"
-        );
-    }
-
-    /// Per-fact-table `measurement_id` hashes carry the family's
-    /// `table_name` as a per-domain seed (see `crate::db::hasher_for`),
-    /// so two families sharing the same `commit_sha + dataset + format`
-    /// dim tuple still produce distinct row keys. This regression test
-    /// builds a [`crate::records::CompressionTime`] and a
-    /// [`crate::records::CompressionSize`] over the same overlapping
-    /// dim subset and asserts the hashes are non-zero and distinct.
-    #[test]
-    fn measurement_id_per_family_seed_keeps_overlapping_dims_distinct() {
-        use crate::records::CompressionSize;
-        use crate::records::CompressionTime;
-
-        let ct = Record::CompressionTime(CompressionTime {
-            commit_sha: "0000000000000000000000000000000000000000".into(),
-            dataset: "shared".into(),
-            dataset_variant: None,
-            format: "vortex".into(),
-            op: "encode".into(),
-            value_ns: 0,
-            all_runtimes_ns: vec![],
-            env_triple: None,
-        });
-        let cs = Record::CompressionSize(CompressionSize {
-            commit_sha: "0000000000000000000000000000000000000000".into(),
-            dataset: "shared".into(),
-            dataset_variant: None,
-            format: "vortex".into(),
-            value_bytes: 0,
-        });
-        let ct_id = (COMPRESSION_TIMES.measurement_id)(&ct);
-        let cs_id = (COMPRESSION_SIZES.measurement_id)(&cs);
-        assert_ne!(ct_id, 0, "compression_times hash must not be zero");
-        assert_ne!(cs_id, 0, "compression_sizes hash must not be zero");
-        assert_ne!(
-            ct_id, cs_id,
-            "per-family table_name seed must keep overlapping-dim hashes distinct \
-             across families"
-        );
-    }
-}
diff --git a/benchmarks-website/server/src/html/chart.rs b/benchmarks-website/server/src/html/chart.rs
deleted file mode 100644
index f6572fe8f06..00000000000
--- a/benchmarks-website/server/src/html/chart.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Chart and group permalink page bodies.
-//!
-//! The chart page renders a single chart card with its payload inlined.
-
-use maud::Markup;
-use maud::PreEscaped;
-use maud::html;
-
-use super::landing::downsample_badge_slot;
-use super::render::escape_json_for_script;
-use super::toolbar::per_chart_toolbar;
-use super::toolbar::range_strip;
-use crate::api::ChartResponse;
-use crate::api::CommitWindow;
-
-/// Body for `/chart/{slug}`: a single chart-card with the payload inlined.
-pub(super) fn chart_body(
-    chart: &ChartResponse,
-    slug: &str,
-    payload_json: &str,
-    window: &CommitWindow,
-) -> Markup {
-    let series_count = chart.series.len();
-    let commit_count = chart.commits.len();
-    let payload_window = window.url_value();
-    html! {
-        p.chart-meta {
-            "unit: " code { (chart.unit_kind.label()) }
-            " · "
-            (series_count) " series · "
-            (commit_count) " commit" @if commit_count != 1 { "s" }
-            (downsample_badge_slot())
-        }
-        section.chart-card
-            data-chart-index="0"
-            data-chart-slug=(slug)
-            data-payload-window=(payload_window) {
-            (per_chart_toolbar(0))
-            div.chart-tooltip-host {}
-            div.chart-wrap {
-                canvas data-chart-index="0" {}
-            }
-            (range_strip(0))
-            // Embedded JSON; rendered as text content so JSON `<` / `>` are HTML-escaped.
-            script id="chart-data-0" type="application/json" {
-                (PreEscaped(escape_json_for_script(payload_json)))
-            }
-        }
-        noscript {
-            p.no-script { "JavaScript is required to render the chart." }
-        }
-    }
-}
diff --git a/benchmarks-website/server/src/html/filter.rs b/benchmarks-website/server/src/html/filter.rs
deleted file mode 100644
index df799c6e2ad..00000000000
--- a/benchmarks-website/server/src/html/filter.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Global filter dropdown markup + the on-page filter-state JSON bridge.
-
-use maud::Markup;
-use maud::PreEscaped;
-use maud::html;
-
-use super::FilterState;
-use super::render::escape_json_for_script;
-use super::render::filter_icon;
-use crate::api;
-
-/// Filter dropdown rendered inside the sticky header. The trigger button
-/// shows an icon + active-count badge; clicking it opens a panel with two
-/// rows of toggle chips that hide/show series by `engine` or `format`
-/// across every chart on the page.
-///
-/// Chip toggle semantics (driven by `chart-init.js`):
-/// - The chip's active state mirrors the visibility of that engine/format.
-///   With every chip in a row active, no filter is applied for that
-///   dimension. Click any chip to toggle it independently.
-/// - The "all" chip is a one-shot reset: clicking it forces every chip in
-///   that row back to active.
-///
-/// Chip universes are sourced from [`api::collect_filter_universe`] so a new
-/// engine or format showing up in ingest automatically grows the panel;
-/// nothing is hard-coded.
-pub(super) fn filter_dropdown(
-    universe: &api::FilterUniverse,
-    filter: &FilterState,
-    active_count: usize,
-) -> Markup {
-    html! {
-        div.filter-dropdown data-role="global-filter-bar" {
-            button.control-btn.filter-trigger
-                type="button"
-                data-role="filter-trigger"
-                aria-haspopup="true"
-                aria-expanded="false" {
-                (filter_icon())
-                span { "Filters" }
-                @if active_count > 0 {
-                    span.filter-badge data-role="filter-badge" { (active_count) }
-                }
-            }
-            div.filter-panel data-role="filter-panel" hidden {
-                (filter_row("Engine", "engine", &universe.engines, &filter.engines))
-                (filter_row("Format", "format", &universe.formats, &filter.formats))
-            }
-        }
-    }
-}
-
-/// Render one row of chips inside the filter panel. `active_list` is empty
-/// when no filter is applied for this dimension — every chip renders active.
-/// When non-empty, only chips whose value is in the list render active.
-fn filter_row(label: &str, dim: &str, universe: &[String], active_list: &[String]) -> Markup {
-    let dim_filtered = !active_list.is_empty();
-    html! {
-        div.global-filter-row {
-            span.global-filter-label { (label) }
-            button.filter-chip.filter-chip--all
-                type="button"
-                data-filter=(dim)
-                data-value="*"
-                aria-pressed="false" {
-                "all"
-            }
-            @for value in universe {
-                @let active = !dim_filtered || active_list.iter().any(|v| v == value);
-                button.filter-chip
-                    type="button"
-                    data-filter=(dim)
-                    data-value=(value)
-                    .filter-chip--active[active]
-                    aria-pressed=(active) {
-                    (value)
-                }
-            }
-        }
-    }
-}
-
-/// Embed the active filter state as a small JSON payload the client picks up
-/// on hydration. Cheaper to read than re-parsing `location.search` and
-/// guarantees the server- and client-side decoders agree.
-pub(super) fn filter_state_script(filter: &FilterState) -> Markup {
-    let json = serde_json::to_string(filter).unwrap_or_else(|_| "{}".into());
-    html! {
-        script id="bench-filter-state" type="application/json" {
-            (PreEscaped(escape_json_for_script(&json)))
-        }
-    }
-}
diff --git a/benchmarks-website/server/src/html/landing.rs b/benchmarks-website/server/src/html/landing.rs
deleted file mode 100644
index 51a878ce8c1..00000000000
--- a/benchmarks-website/server/src/html/landing.rs
+++ /dev/null
@@ -1,255 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Landing-page body rendering.
-//!
-//! Every group is wrapped in a collapsed `<details>`; the first group's
-//! chart-card shells are hydrated from versioned group shard artifacts on
-//! first intent/open.
-
-use maud::Markup;
-use maud::html;
-
-use super::render::filter_icon;
-use super::summary::summary_markup;
-use super::toolbar::per_chart_toolbar;
-use super::toolbar::range_strip;
-use crate::api;
-use crate::api::Summary;
-
-/// One group's worth of data for the landing page.
-///
-/// Every disclosure renders closed by default on the landing page. Chart
-/// payloads are fetched from versioned materialized group shards, so the
-/// cold HTML stays metadata-only while first-open hydration is served from
-/// memory on the server.
-pub(super) struct LandingGroup {
-    /// Display name rendered in the disclosure header.
-    pub(super) name: String,
-    /// Slug for `/api/group/{slug}` exposed as stable group metadata.
-    pub(super) slug: String,
-    /// Active materialized read generation.
-    pub(super) generation: String,
-    /// Number of latest-100 shard artifacts available for this group.
-    pub(super) shard_count: usize,
-    /// URL prefix ending in `/shards/`; JS appends the shard index.
-    pub(super) shard_prefix: String,
-    /// Whether the group's `<details>` should render open initially.
-    pub(super) open: bool,
-    /// Optional editorial blurb rendered as a hover tooltip on the
-    /// disclosure title's info-icon.
-    pub(super) description: Option<String>,
-    /// Optional v2-compatible summary card rendered above the chart grid.
-    pub(super) summary: Option<Summary>,
-    /// Chart links for every chart in the group. Always present - we need
-    /// the slugs server-side so the chart-card shell can carry
-    /// `data-chart-slug` for the lazy fetch.
-    pub(super) chart_links: Vec<api::ChartLink>,
-}
-
-/// Render the landing-page body - one `<section>` per group, each wrapping a
-/// `<details>` disclosure. Each `<canvas>` carries a unique
-/// `data-chart-index` integer (used by `chart-init.js` to wire toolbar
-/// controls to canvases by id) and a `data-chart-slug` (used to resolve the
-/// per-chart payload via the enclosing `<section.group-details>`'s
-/// `data-group-shard-prefix`). The landing page emits NO inline JSON
-/// payloads - every chart hydrates from a versioned shard artifact on
-/// first intent/open. The `chart-data-N` inline-script id is permalink-page
-/// only and lives in `chart.rs`.
-pub(super) fn landing_body(groups: &[LandingGroup], universe: &api::FilterUniverse) -> Markup {
-    if groups.is_empty() {
-        return html! {
-            p.empty { "No data ingested yet." }
-        };
-    }
-    let total_charts: usize = groups.iter().map(|g| g.chart_links.len()).sum();
-    // Give every chart a unique `data-chart-index` integer so chart-init.js
-    // can wire each canvas to its toolbar controls; the index is per-page
-    // unique, not a lookup key.
-    let mut idx_iter = 0usize..total_charts;
-    html! {
-        @for group in groups.iter() {
-            section.group-details
-                data-group-name=(group.name)
-                data-group-slug=(group.slug)
-                data-artifact-generation=(group.generation)
-                data-group-shard-count=(group.shard_count)
-                data-group-shard-prefix=(group.shard_prefix) {
-                details.group-disclosure open[group.open] {
-                    summary.group-summary {
-                        span.group-summary-row {
-                            span.group-name { (group.name) }
-                            (group_description_icon(group.description.as_deref()))
-                            span.group-count {
-                                (group.chart_links.len()) " chart" @if group.chart_links.len() != 1 { "s" }
-                            }
-                        }
-                    }
-                }
-                (summary_markup(group.summary.as_ref()))
-                (per_group_toolbar(universe))
-                div.chart-grid {
-                    @for link in &group.chart_links {
-                        @let idx = idx_iter.next().expect("indices match charts");
-                        (chart_card(link, idx))
-                    }
-                }
-            }
-        }
-        noscript {
-            p.no-script { "JavaScript is required to render the charts." }
-        }
-    }
-}
-
-/// Render the per-group toolbar that lets the user override the global filter
-/// and Y-axis scale across every chart in the group. The toolbar is a sibling
-/// of `.chart-grid`; CSS hides it when the enclosing `<details>` is closed,
-/// mirroring the rule that hides `.chart-grid` itself.
-///
-/// Layout: Y-axis buttons on the left, a centered "Filter series" dropdown
-/// trigger, and a Reset button on the right. The dropdown panel contains
-/// engine and format macro chips (which expand to "toggle every series with
-/// this engine/format") plus a series row whose chips are populated by JS as
-/// charts in the group hydrate and surface their `payload.series_meta`.
-///
-/// Resolution layering (driven by `chart-init.js`):
-/// - Per-card legend overrides win over everything.
-/// - The per-group filter (`hiddenSeries`) hides next.
-/// - The global filter hides last.
-/// - The Y-axis pass skips charts where the user previously clicked the
-///   per-chart Y toolbar (`canvas.__bench_y_user_set`).
-fn per_group_toolbar(universe: &api::FilterUniverse) -> Markup {
-    html! {
-        section.group-toolbar data-role="group-toolbar" {
-            div.toolbar-group.group-toolbar-y role="group" aria-label="Group Y-axis scale" {
-                span.toolbar-label { "Y" }
-                // Linear is the resting default (matches each chart's
-                // own default) so it ships highlighted; the JS keeps it
-                // lit while the per-group Y is unset or explicitly linear.
-                button.toolbar-btn.toolbar-btn--active
-                    type="button" data-group-y="linear" { "linear" }
-                button.toolbar-btn type="button" data-group-y="log" { "log" }
-            }
-            div.group-filter-dropdown data-role="group-filter-dropdown" {
-                button.control-btn.filter-trigger.group-filter-trigger
-                    type="button"
-                    data-role="group-filter-trigger"
-                    aria-haspopup="true"
-                    aria-expanded="false" {
-                    (filter_icon())
-                    span { "Filter series" }
-                }
-                div.filter-panel.group-filter-panel data-role="group-filter-panel" hidden {
-                    (group_macro_row("Engine", "engine", &universe.engines))
-                    (group_macro_row("Format", "format", &universe.formats))
-                    div.global-filter-row.group-series-row {
-                        span.global-filter-label { "Series" }
-                        button.filter-chip.filter-chip--all
-                            type="button"
-                            data-group-filter="series"
-                            data-value="*"
-                            aria-pressed="false" {
-                            "all"
-                        }
-                        // Series chips hydrate client-side once a chart in this
-                        // group exposes its `payload.series_meta`. Until then
-                        // the row only shows the Engine/Format macros above.
-                        div.group-series-chips data-role="group-series-chips" {}
-                    }
-                }
-            }
-            button.group-toolbar-reset
-                type="button"
-                data-role="group-toolbar-reset" {
-                "Reset group"
-            }
-        }
-    }
-}
-
-/// Render an engine/format macro row inside the per-group filter panel. The
-/// macro chip click bulk-toggles every known series whose `engine`/`format`
-/// matches; the chip's active state reflects "every matching series is
-/// currently visible". `data-group-filter` distinguishes these chips from the
-/// global filter's `data-filter` ones so the click handler can route them to
-/// the per-group state.
-fn group_macro_row(label: &str, dim: &str, universe: &[String]) -> Markup {
-    html! {
-        div.global-filter-row.group-macro-row {
-            span.global-filter-label { (label) }
-            button.filter-chip.filter-chip--all
-                type="button"
-                data-group-filter=(dim)
-                data-value="*"
-                aria-pressed="false" {
-                "all"
-            }
-            @for value in universe {
-                button.filter-chip.filter-chip--active
-                    type="button"
-                    data-group-filter=(dim)
-                    data-value=(value)
-                    aria-pressed="true" {
-                    (value)
-                }
-            }
-        }
-    }
-}
-
-/// Render the small ⓘ info icon that surfaces the group's editorial
-/// description on hover and on focus. The CSS-only tooltip uses a
-/// `data-tooltip` attribute so it shows below the icon (see `style.css`'s
-/// `.group-info-icon` rule). The icon itself is keyboard-focusable and
-/// `aria-label`-ed so the description is reachable via the keyboard and to
-/// screen readers.
-///
-/// Returns an empty markup fragment when `description` is `None` so groups
-/// without a canonical blurb (e.g. vector-search groups) render unchanged.
-pub(super) fn group_description_icon(description: Option<&str>) -> Markup {
-    let Some(text) = description else {
-        return html! {};
-    };
-    html! {
-        span.group-info-icon
-            tabindex="0"
-            role="note"
-            aria-label=(text)
-            data-tooltip=(text) {
-            "ⓘ"
-        }
-    }
-}
-
-/// Render one chart-card shell. The payload arrives later from the group's
-/// materialized shard artifact.
-fn chart_card(link: &api::ChartLink, idx: usize) -> Markup {
-    let permalink = format!("/chart/{}", link.slug);
-    html! {
-        section.chart-card data-chart-index=(idx) data-chart-slug=(link.slug) {
-            h3.chart-card-title {
-                a href=(permalink) { (link.name) }
-                (downsample_badge_slot())
-            }
-            (per_chart_toolbar(idx))
-            div.chart-tooltip-host {}
-            div.chart-wrap {
-                canvas data-chart-index=(idx) {}
-            }
-            (range_strip(idx))
-        }
-    }
-}
-
-/// Empty hidden slot for the LTTB badge. `chart-init.js` flips it on when
-/// the *currently visible* commit range exceeds the LTTB threshold and the
-/// rendered point count is therefore less than the raw point count in that
-/// range.
-pub(super) fn downsample_badge_slot() -> Markup {
-    html! {
-        span.chart-badge.chart-badge--downsampled
-            data-role="downsample-badge"
-            hidden {}
-    }
-}
diff --git a/benchmarks-website/server/src/html/mod.rs b/benchmarks-website/server/src/html/mod.rs
deleted file mode 100644
index 3128ab8d55b..00000000000
--- a/benchmarks-website/server/src/html/mod.rs
+++ /dev/null
@@ -1,387 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! HTML routes for the bench.vortex.dev v3 web UI.
-//!
-//! Three pages, all backed by the same per-chart UX:
-//! - `GET /` - landing page. Every group is a collapsible `<details>`,
-//!   all collapsed by default; the user picks which to expand. Every group
-//!   ships chart-card shells plus versioned shard metadata, and JS hydrates
-//!   the latest-100 payloads from materialized artifacts on intent/open.
-//! - `GET /chart/{slug}` - single chart page; permalink for sharing.
-//! - `GET /group/{slug}` - every chart shell in one group on a single page,
-//!   opened by default and hydrated through the same shard path.
-//!
-//! Each chart card owns its own compact toolbar (scope slider + Y-axis). There
-//! is no page-level toolbar - every chart is independent. Scope is
-//! **zoom-as-scope**: each chart fetches a generous window once, then the
-//! toolbar manipulates `chart.options.scales.x.min`/`max` to set the visible
-//! window. No refetches on scope change.
-//!
-//! HTML routes default to the latest-100 materialized window. Users who
-//! pan/zoom beyond that window trigger an explicit `?n=all` chart fetch.
-//! Visual downsampling happens client-side in `chart-init.js`, applied only
-//! to the currently visible commit range.
-//!
-//! URL query param `?n=` is accepted as a power-user override on the
-//! initial fetch but is not written back from the toolbar. Per-chart UI
-//! state is intentionally not persisted in the URL - the user feedback
-//! emphasised that this UX should feel local-and-immediate, not "share a
-//! perfect view via URL". Permalinks (`/chart/{slug}`, `/group/{slug}`)
-//! are the sharing mechanism, not query strings.
-//!
-//! Slugs are opaque strings the server received from `/api/groups`; the
-//! handler echoes them straight into [`crate::slug::ChartKey::from_slug`]
-//! (or [`crate::slug::GroupKey::from_slug`]) without parsing.
-//!
-//! Static assets (Chart.js + zoom plugin + CSS + the small hydration
-//! script) are served from `/static/...` via [`include_bytes!`] so the
-//! binary is fully self-contained.
-//!
-//! Submodules (all crate-private):
-//! - `render`        - page chrome (header, theme bootstrap, error page,
-//!   `escape_json_for_script`).
-//! - `landing`       - landing-page body + chart-card shell rendering.
-//! - `chart`         - chart and group permalink page bodies.
-//! - `summary`       - group summary card rendering.
-//! - `filter`        - filter dropdown + on-page filter-state JSON.
-//! - `toolbar`       - per-chart scope slider, Y-axis switch, range strip.
-//! - `static_assets` - `include_bytes!`'d JS/CSS/PNG handlers.
-
-mod chart;
-mod filter;
-mod landing;
-mod render;
-mod static_assets;
-mod summary;
-mod toolbar;
-
-use axum::Router;
-use axum::extract::Path;
-use axum::extract::Query;
-use axum::extract::State;
-use axum::http::StatusCode;
-use axum::response::IntoResponse;
-use axum::response::Response;
-use axum::routing::get;
-use serde::Deserialize;
-
-use self::chart::chart_body;
-use self::landing::LandingGroup;
-use self::landing::landing_body;
-use self::render::PageScripts;
-use self::render::error_page;
-use self::render::render_page;
-use self::static_assets::serve_chart_init_js;
-use self::static_assets::serve_chart_js;
-use self::static_assets::serve_chart_zoom_js;
-use self::static_assets::serve_icon_dark_png;
-use self::static_assets::serve_icon_light_png;
-use self::static_assets::serve_style_css;
-use self::static_assets::serve_vortex_black_png;
-use self::static_assets::serve_vortex_white_png;
-use crate::api;
-use crate::api::CommitWindow;
-use crate::api::Group;
-use crate::app::AppState;
-use crate::read_model::ReadGeneration;
-use crate::slug::ChartKey;
-use crate::slug::GroupKey;
-
-/// HTML routes mounted under `/`.
-pub fn router() -> Router<AppState> {
-    Router::new()
-        .route("/", get(landing))
-        .route("/chart/{slug}", get(chart_page))
-        .route("/group/{slug}", get(group_page))
-        .route("/static/chart.umd.js", get(serve_chart_js))
-        .route(
-            "/static/chartjs-plugin-zoom.umd.min.js",
-            get(serve_chart_zoom_js),
-        )
-        .route("/static/chart-init.js", get(serve_chart_init_js))
-        .route("/static/style.css", get(serve_style_css))
-        .route("/Vortex_Black_NoBG.png", get(serve_vortex_black_png))
-        .route("/Vortex_White_NoBG.png", get(serve_vortex_white_png))
-        .route("/static/icon-light.png", get(serve_icon_light_png))
-        .route("/static/icon-dark.png", get(serve_icon_dark_png))
-}
-
-/// Query string for HTML routes. `?n=` overrides the commit window;
-/// `?engine=` and `?format=` carry the global filter bar's selection so a
-/// shared link or refresh preserves which engines/formats are visible. The
-/// per-chart toolbar (Y axis, scope slider) remains local-only - its state
-/// is intentionally not in the URL.
-#[derive(Debug, Default, Deserialize)]
-pub struct UiQuery {
-    /// Override for the per-chart fetch size. Numeric values are clamped by
-    /// [`CommitWindow::parse`]; `all` opts into the full-history fallback.
-    pub n: Option<String>,
-    /// Comma-separated list of engines to keep visible across every chart.
-    /// Empty / unset means no engine filter is active. Unknown engines are
-    /// preserved verbatim so a stale URL still survives a chip-universe
-    /// expansion.
-    pub engine: Option<String>,
-    /// Comma-separated list of formats to keep visible across every chart.
-    /// Same shape as `engine`.
-    pub format: Option<String>,
-}
-
-impl UiQuery {
-    /// Resolve the [`CommitWindow`] for HTML routes. Defaults to the
-    /// materialized latest-100 window; `?n=all` opts into the slower
-    /// full-history fallback.
-    fn fetch_window(&self) -> CommitWindow {
-        match self.n.as_deref() {
-            Some(_) => CommitWindow::parse(self.n.as_deref()),
-            None => CommitWindow::default(),
-        }
-    }
-
-    /// Parse `?engine=`/`?format=` into a deduplicated, trimmed [`FilterState`].
-    /// Empty entries (e.g. trailing commas) are dropped; an entirely empty
-    /// param means "no filter active" and is encoded as an empty `Vec`.
-    fn filter_state(&self) -> FilterState {
-        FilterState {
-            engines: parse_csv(self.engine.as_deref()),
-            formats: parse_csv(self.format.as_deref()),
-        }
-    }
-}
-
-/// Parsed filter selection from `?engine=` / `?format=`.
-///
-/// An empty `Vec` means "all chips active" (no filter); a non-empty `Vec`
-/// is the explicit allowlist for that dimension.
-#[derive(Debug, Default, Clone, serde::Serialize)]
-pub struct FilterState {
-    /// Engine names the URL allowlists; empty means no filter.
-    pub engines: Vec<String>,
-    /// Format names the URL allowlists; empty means no filter.
-    pub formats: Vec<String>,
-}
-
-fn parse_csv(raw: Option<&str>) -> Vec<String> {
-    let Some(raw) = raw else { return Vec::new() };
-    let mut seen = std::collections::BTreeSet::new();
-    raw.split(',')
-        .map(str::trim)
-        .filter(|s| !s.is_empty())
-        .filter(|s| seen.insert(s.to_string()))
-        .map(str::to_string)
-        .collect()
-}
-
-async fn landing(State(state): State<AppState>, Query(ui): Query<UiQuery>) -> Response {
-    // The landing page intentionally ignores `?n=` for group hydration. It
-    // always starts from the materialized latest-100 shards, and
-    // `chart-init.js` fetches `/api/chart/{slug}?n=all` only after a user asks
-    // for history beyond that loaded window.
-    let filter = ui.filter_state();
-    let generation = state.read_store.active();
-    let groups = generation.groups();
-    let universe = generation.filter_universe();
-    let landing_groups = collect_landing_groups(&generation, &groups, None);
-    let scripts = if landing_groups.is_empty() {
-        PageScripts::Empty
-    } else {
-        PageScripts::Chart
-    };
-    render_page(
-        "Vortex Benchmarks",
-        "Vortex benchmarks (v3 alpha)",
-        landing_body(&landing_groups, universe.as_ref()),
-        scripts,
-        Some(universe.as_ref()),
-        &filter,
-    )
-    .into_response()
-}
-
-/// Build a landing/group-page shell view. Each group carries the active
-/// generation id and shard prefix; no chart payload JSON is inlined.
-fn collect_landing_groups(
-    generation: &ReadGeneration,
-    groups: &[Group],
-    open_slug: Option<&str>,
-) -> Vec<LandingGroup> {
-    let mut out = Vec::with_capacity(groups.len());
-    for group in groups {
-        let shard_prefix = format!(
-            "/api/artifacts/{}/groups/{}/shards/",
-            generation.id(),
-            group.slug
-        );
-        out.push(LandingGroup {
-            name: group.name.clone(),
-            slug: group.slug.clone(),
-            generation: generation.id().to_string(),
-            shard_count: generation.group_shard_count(&group.slug),
-            shard_prefix,
-            open: open_slug == Some(group.slug.as_str()),
-            description: group.description.clone(),
-            summary: group.summary.clone(),
-            chart_links: group.charts.clone(),
-        });
-    }
-    out
-}
-
-async fn chart_page(
-    State(state): State<AppState>,
-    Path(slug): Path<String>,
-    Query(ui): Query<UiQuery>,
-) -> Response {
-    let key = match ChartKey::from_slug(&slug) {
-        Ok(key) => key,
-        Err(err) => {
-            tracing::warn!(error = ?err, slug, "chart_page: invalid slug");
-            return error_page(StatusCode::NOT_FOUND, "chart not found").into_response();
-        }
-    };
-
-    let window = ui.fetch_window();
-    let (chart, payload_json) = if is_materialized_window(&window) {
-        let generation = state.read_store.active();
-        let Some(chart) = generation.chart_payload(&slug) else {
-            return error_page(StatusCode::NOT_FOUND, "chart not found").into_response();
-        };
-        let Some(artifact) = generation.chart_artifact(&slug) else {
-            return error_page(StatusCode::NOT_FOUND, "chart not found").into_response();
-        };
-        let payload_json = match std::str::from_utf8(artifact.identity()) {
-            Ok(s) => s.to_string(),
-            Err(err) => {
-                tracing::error!(error = ?err, "chart_page: artifact utf8 failed");
-                return error_page(StatusCode::INTERNAL_SERVER_ERROR, "internal error")
-                    .into_response();
-            }
-        };
-        (chart, payload_json)
-    } else {
-        let chart = match api::cached_chart_payload(&state, &slug, &key, &window).await {
-            Ok(Some(c)) => c,
-            Ok(None) => {
-                return error_page(StatusCode::NOT_FOUND, "chart not found").into_response();
-            }
-            Err(err) => {
-                tracing::error!(error = ?err, "chart_page: chart_payload failed");
-                return error_page(StatusCode::INTERNAL_SERVER_ERROR, "internal error")
-                    .into_response();
-            }
-        };
-
-        let payload_json = match serde_json::to_string(&*chart) {
-            Ok(s) => s,
-            Err(err) => {
-                tracing::error!(error = ?err, "chart_page: serialize failed");
-                return error_page(StatusCode::INTERNAL_SERVER_ERROR, "internal error")
-                    .into_response();
-            }
-        };
-        (chart, payload_json)
-    };
-
-    let title = format!("{} - Vortex Benchmarks", chart.display_name);
-    let subtitle = chart.display_name.clone();
-    let filter = ui.filter_state();
-    let universe = api::cached_filter_universe(&state).await.ok();
-    render_page(
-        &title,
-        &subtitle,
-        chart_body(&chart, &slug, &payload_json, &window),
-        PageScripts::Chart,
-        universe.as_deref(),
-        &filter,
-    )
-    .into_response()
-}
-
-async fn group_page(
-    State(state): State<AppState>,
-    Path(slug): Path<String>,
-    Query(ui): Query<UiQuery>,
-) -> Response {
-    let key = match GroupKey::from_slug(&slug) {
-        Ok(k) => k,
-        Err(err) => {
-            tracing::warn!(error = ?err, slug, "group_page: invalid slug");
-            return error_page(StatusCode::NOT_FOUND, "group not found").into_response();
-        }
-    };
-    let group_slug = key.to_slug();
-    let generation = state.read_store.active();
-    let groups = generation.groups();
-    let Some(group) = groups.iter().find(|group| group.slug == group_slug) else {
-        return error_page(StatusCode::NOT_FOUND, "group not found").into_response();
-    };
-    let title = format!("{} - Vortex Benchmarks", group.name);
-    let subtitle = group.name.clone();
-    let filter = ui.filter_state();
-    let universe = generation.filter_universe();
-    let group_shell =
-        collect_landing_groups(&generation, std::slice::from_ref(group), Some(&group_slug));
-    render_page(
-        &title,
-        &subtitle,
-        landing_body(&group_shell, universe.as_ref()),
-        PageScripts::Chart,
-        Some(universe.as_ref()),
-        &filter,
-    )
-    .into_response()
-}
-
-fn is_materialized_window(window: &CommitWindow) -> bool {
-    matches!(window, CommitWindow::Last(n) if n.get() == api::DEFAULT_COMMIT_WINDOW)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn fetch_window_default_is_latest_100() {
-        let ui = UiQuery::default();
-        match ui.fetch_window() {
-            CommitWindow::Last(n) => assert_eq!(n.get(), api::DEFAULT_COMMIT_WINDOW),
-            CommitWindow::All => panic!(),
-        }
-    }
-
-    #[test]
-    fn fetch_window_respects_n_override() {
-        let ui = UiQuery {
-            n: Some("25".into()),
-            ..Default::default()
-        };
-        match ui.fetch_window() {
-            CommitWindow::Last(n) => assert_eq!(n.get(), 25),
-            CommitWindow::All => panic!(),
-        }
-        let ui = UiQuery {
-            n: Some("all".into()),
-            ..Default::default()
-        };
-        assert!(matches!(ui.fetch_window(), CommitWindow::All));
-    }
-
-    #[test]
-    fn filter_state_parses_csv_and_dedupes() {
-        let ui = UiQuery {
-            engine: Some("duckdb, datafusion ,duckdb".into()),
-            format: Some(",, vortex-file-compressed ,".into()),
-            ..Default::default()
-        };
-        let f = ui.filter_state();
-        assert_eq!(f.engines, vec!["duckdb", "datafusion"]);
-        assert_eq!(f.formats, vec!["vortex-file-compressed"]);
-    }
-
-    #[test]
-    fn filter_state_default_is_empty() {
-        let f = UiQuery::default().filter_state();
-        assert!(f.engines.is_empty());
-        assert!(f.formats.is_empty());
-    }
-}
diff --git a/benchmarks-website/server/src/html/render.rs b/benchmarks-website/server/src/html/render.rs
deleted file mode 100644
index c5acacfd179..00000000000
--- a/benchmarks-website/server/src/html/render.rs
+++ /dev/null
@@ -1,349 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Page chrome: the outer `<html>` shell, sticky header, theme bootstrap,
-//! SVG icon helpers, error page.
-
-use axum::http::StatusCode;
-use axum::response::IntoResponse;
-use axum::response::Response;
-use maud::DOCTYPE;
-use maud::Markup;
-use maud::PreEscaped;
-use maud::html;
-
-use super::FilterState;
-use super::filter::filter_dropdown;
-use super::filter::filter_state_script;
-use super::static_assets::versioned_asset;
-use crate::api;
-
-/// Which scripts the page wants pulled in.
-pub(super) enum PageScripts {
-    /// Empty database - skip Chart.js entirely.
-    Empty,
-    /// Any page with at least one chart-card. Pulls Chart.js + zoom plugin.
-    Chart,
-}
-
-/// Render the full HTML page wrapper around `body`. The header carries the
-/// global filter dropdown when `universe` is non-empty.
-pub(super) fn render_page(
-    title: &str,
-    _header_subtitle: &str,
-    body: Markup,
-    scripts: PageScripts,
-    universe: Option<&api::FilterUniverse>,
-    filter: &FilterState,
-) -> Markup {
-    let style_href = versioned_asset("/static/style.css");
-    let chart_js_src = versioned_asset("/static/chart.umd.js");
-    let chart_zoom_src = versioned_asset("/static/chartjs-plugin-zoom.umd.min.js");
-    let chart_init_src = versioned_asset("/static/chart-init.js");
-    html! {
-        (DOCTYPE)
-        html lang="en" {
-            head {
-                meta charset="utf-8";
-                meta name="viewport" content="width=device-width, initial-scale=1";
-                title { (title) }
-                (favicon_links())
-                (web_font_links())
-                (theme_bootstrap_script())
-                link rel="stylesheet" href=(style_href);
-            }
-            body {
-                (filter_state_script(filter))
-                (site_header(universe, filter))
-                main { (body) }
-                (site_footer())
-                @match scripts {
-                    PageScripts::Empty => {
-                        script src=(chart_init_src) defer {}
-                    },
-                    PageScripts::Chart => {
-                        script src=(chart_js_src) defer {}
-                        script src=(chart_zoom_src) defer {}
-                        script src=(chart_init_src) defer {}
-                    },
-                }
-            }
-        }
-    }
-}
-
-/// Bottom-of-page footer that surfaces the build's git SHA so operators
-/// (and curious visitors) can correlate what they're looking at to a
-/// specific commit. `VORTEX_BENCH_BUILD_SHA` is captured by `build.rs`
-/// (same source `/health` uses), so the footer and the health probe are
-/// always in lockstep.
-///
-/// When the binary was built outside a git checkout (shallow CI clone,
-/// source tarball) the SHA is the literal `"unknown"`; we render the
-/// label without a link in that case.
-fn site_footer() -> Markup {
-    let full_sha = env!("VORTEX_BENCH_BUILD_SHA");
-    let short_sha: &str = full_sha.get(..7).unwrap_or(full_sha);
-    let commit_url = format!("https://github.com/vortex-data/vortex/commit/{full_sha}");
-    html! {
-        footer.site-footer {
-            span.site-footer-label { "build " }
-            @if full_sha == "unknown" {
-                code.site-footer-sha { (short_sha) }
-            } @else {
-                a.site-footer-sha href=(commit_url) rel="noopener noreferrer" target="_blank" {
-                    code { (short_sha) }
-                }
-            }
-        }
-    }
-}
-
-/// External web-font links - Geist (sans + mono) from unpkg and Funnel
-/// Display from Google Fonts. Mirrors v2's `index.html` so the v3 site
-/// reads in the same typeface (Geist for body, Funnel Display for
-/// headings, Geist Mono for the monospaced metrics columns). The
-/// preconnect hints shave a round-trip off the first load.
-fn web_font_links() -> Markup {
-    html! {
-        link rel="preconnect" href="https://fonts.googleapis.com";
-        link rel="preconnect" href="https://fonts.gstatic.com" crossorigin;
-        link rel="stylesheet"
-            href="https://fonts.googleapis.com/css2?family=Funnel+Display:wght@300;400;500;600;700;800&display=swap";
-        link rel="stylesheet" href="https://unpkg.com/geist@1.3.0/dist/fonts/geist-sans/style.css";
-        link rel="stylesheet" href="https://unpkg.com/geist@1.3.0/dist/fonts/geist-mono/style.css";
-    }
-}
-
-/// Browser tab icon links. Two transparent square sigils - the black
-/// one for light-mode tabs, the white one for dark-mode tabs - picked
-/// via `prefers-color-scheme` media queries. A third unmediated link
-/// covers browsers that don't honour the media query (the dark version
-/// is used since GitHub-style developer audiences skew dark-mode); the
-/// `apple-touch-icon` is also the dark sigil so the iOS home-screen
-/// icon shows the sigil over iOS's default tile colour.
-///
-/// v2's `public/favicon-*.png` set is intentionally not used here:
-/// those assets have white backgrounds baked in, which render as a
-/// glaring white square on dark-mode tabs.
-fn favicon_links() -> Markup {
-    let icon_light = versioned_asset("/static/icon-light.png");
-    let icon_dark = versioned_asset("/static/icon-dark.png");
-    html! {
-        link rel="icon" type="image/png" media="(prefers-color-scheme: light)" href=(icon_light);
-        link rel="icon" type="image/png" media="(prefers-color-scheme: dark)" href=(icon_dark);
-        link rel="icon" type="image/png" href=(icon_dark);
-        link rel="apple-touch-icon" href=(icon_dark);
-    }
-}
-
-fn theme_bootstrap_script() -> Markup {
-    html! {
-        script {
-            (PreEscaped(
-                r#"(function(){try{var t=localStorage.getItem("bench-theme");if(t==="light"||t==="dark"){document.documentElement.dataset.theme=t;}}catch(e){}})();"#
-            ))
-        }
-    }
-}
-
-fn site_header(universe: Option<&api::FilterUniverse>, filter: &FilterState) -> Markup {
-    let black_logo = versioned_asset("/Vortex_Black_NoBG.png");
-    let white_logo = versioned_asset("/Vortex_White_NoBG.png");
-    let show_filters = universe
-        .map(|u| !u.engines.is_empty() || !u.formats.is_empty())
-        .unwrap_or(false);
-    let active_count = filter.engines.len() + filter.formats.len();
-    html! {
-        header.sticky-header {
-            div.header-content {
-                div.header-left {
-                    button.control-btn.nav-mobile-toggle
-                        type="button"
-                        data-role="nav-mobile-toggle"
-                        aria-haspopup="true"
-                        aria-expanded="false"
-                        aria-controls="bench-nav-controls"
-                        aria-label="Toggle navigation menu" {
-                        (hamburger_icon())
-                    }
-                    a.logo-link href="/" aria-label="bench.vortex.dev home" {
-                        img.site-logo.logo-light src=(black_logo) alt="Vortex";
-                        img.site-logo.logo-dark src=(white_logo) alt="Vortex";
-                    }
-                    h1.site-title { "Vortex Benchmarks" }
-                }
-                div.header-center {
-                    div.nav-controls
-                        id="bench-nav-controls"
-                        data-role="nav-controls"
-                        aria-label="Benchmark group controls" {
-                        button.control-btn type="button" data-action="expand-all" {
-                            (chevrons_down_icon())
-                            span { "Expand All" }
-                        }
-                        button.control-btn type="button" data-action="collapse-all" {
-                            (chevrons_up_icon())
-                            span { "Collapse All" }
-                        }
-                        @if show_filters {
-                            (filter_dropdown(universe.expect("show_filters guard"), filter, active_count))
-                        }
-                        // Mobile-only GitHub link rendered inside the
-                        // hamburger panel. Hidden on desktop via CSS;
-                        // the desktop GitHub link in `.header-right`
-                        // covers the wide-viewport case.
-                        a.repo-link.nav-controls-github
-                            href="https://github.com/vortex-data/vortex"
-                            rel="noopener noreferrer"
-                            target="_blank" {
-                            (github_icon())
-                            span { "GitHub" }
-                        }
-                    }
-                }
-                div.header-right {
-                    a.repo-link.repo-link-desktop
-                        href="https://github.com/vortex-data/vortex"
-                        rel="noopener noreferrer"
-                        target="_blank" {
-                        (github_icon())
-                        span { "GitHub" }
-                    }
-                    button.control-btn.theme-toggle type="button" data-role="theme-toggle" data-next-theme="light" aria-label="Toggle color theme" {
-                        (sun_icon())
-                        (moon_icon())
-                        span.theme-toggle-label { "Light" }
-                    }
-                }
-            }
-        }
-    }
-}
-
-fn hamburger_icon() -> Markup {
-    html! {
-        svg.btn-icon viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true" {
-            path d="M4 6h16" {}
-            path d="M4 12h16" {}
-            path d="M4 18h16" {}
-        }
-    }
-}
-
-fn github_icon() -> Markup {
-    html! {
-        svg.github-logo viewBox="0 0 16 16" width="16" height="16" fill="currentColor" aria-hidden="true" {
-            path d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z" {}
-        }
-    }
-}
-
-/// Funnel icon used by the global filter dropdown trigger.
-pub(super) fn filter_icon() -> Markup {
-    html! {
-        svg.btn-icon viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true" {
-            polygon points="22 3 2 3 10 12.46 10 19 14 21 14 12.46 22 3" {}
-        }
-    }
-}
-
-fn chevrons_down_icon() -> Markup {
-    html! {
-        svg.btn-icon viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true" {
-            path d="m7 6 5 5 5-5" {}
-            path d="m7 13 5 5 5-5" {}
-        }
-    }
-}
-
-fn chevrons_up_icon() -> Markup {
-    html! {
-        svg.btn-icon viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true" {
-            path d="m17 18-5-5-5 5" {}
-            path d="m17 11-5-5-5 5" {}
-        }
-    }
-}
-
-fn sun_icon() -> Markup {
-    html! {
-        svg.btn-icon.theme-icon.theme-icon-light viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true" {
-            circle cx="12" cy="12" r="4" {}
-            path d="M12 2v2" {}
-            path d="M12 20v2" {}
-            path d="m4.93 4.93 1.41 1.41" {}
-            path d="m17.66 17.66 1.41 1.41" {}
-            path d="M2 12h2" {}
-            path d="M20 12h2" {}
-            path d="m6.34 17.66-1.41 1.41" {}
-            path d="m19.07 4.93-1.41 1.41" {}
-        }
-    }
-}
-
-fn moon_icon() -> Markup {
-    html! {
-        svg.btn-icon.theme-icon.theme-icon-dark viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true" {
-            path d="M20.99 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 20.99 12.79z" {}
-        }
-    }
-}
-
-/// Render an error page with the same chrome as the main pages.
-pub(super) fn error_page(status: StatusCode, message: &str) -> Response {
-    let style_href = versioned_asset("/static/style.css");
-    let body = html! {
-        (DOCTYPE)
-        html lang="en" {
-            head {
-                meta charset="utf-8";
-                meta name="viewport" content="width=device-width, initial-scale=1";
-                title { (status.as_u16()) " - Vortex Benchmarks" }
-                (favicon_links())
-                (web_font_links())
-                (theme_bootstrap_script())
-                link rel="stylesheet" href=(style_href);
-            }
-            body {
-                (site_header(None, &FilterState::default()))
-                main {
-                    p.empty { (message) }
-                }
-                (site_footer())
-            }
-        }
-    };
-    (status, body).into_response()
-}
-
-/// Make a JSON string safe to embed inside a `<script>` element.
-///
-/// HTML parsers terminate `<script>` early on a literal `</`. Replacing the
-/// `/` with its escaped form keeps the JSON valid while neutering the
-/// terminator. `<!--` is similarly neutralised.
-pub(super) fn escape_json_for_script(s: &str) -> String {
-    s.replace("</", r"<\/")
-        .replace("<!--", r"<\!--")
-        .replace("<script", r"<\script")
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn escape_json_neutralises_script_terminators() {
-        let input = r#"{"x":"</script><script>alert(1)</script>"}"#;
-        let out = escape_json_for_script(input);
-        assert!(!out.contains("</script"));
-        assert!(!out.contains("<script"));
-        assert!(out.contains(r"<\/script"));
-    }
-
-    #[test]
-    fn escape_json_passes_through_safe_strings() {
-        let s = r#"{"a":1,"b":"hello"}"#;
-        assert_eq!(escape_json_for_script(s), s);
-    }
-}
diff --git a/benchmarks-website/server/src/html/static_assets.rs b/benchmarks-website/server/src/html/static_assets.rs
deleted file mode 100644
index aa9579624d7..00000000000
--- a/benchmarks-website/server/src/html/static_assets.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Static asset serving - bundled JS/CSS/PNG via [`include_bytes!`].
-//!
-//! Every static asset is baked into the binary at build time so the v3 server
-//! is fully self-contained. Cache headers force the browser to revalidate on
-//! every load, and the URL carries `?v={STATIC_ASSET_VERSION}` so a UI
-//! release moves all callers to the new bytes.
-
-use axum::http::header;
-use axum::response::IntoResponse;
-use axum::response::Response;
-
-const CHART_JS: &[u8] = include_bytes!("../../static/chart.umd.js");
-const CHART_ZOOM_JS: &[u8] = include_bytes!("../../static/chartjs-plugin-zoom.umd.min.js");
-const CHART_INIT_JS: &[u8] = include_bytes!("../../static/chart-init.js");
-const STYLE_CSS: &[u8] = include_bytes!("../../static/style.css");
-const VORTEX_BLACK_PNG: &[u8] = include_bytes!("../../../public/Vortex_Black_NoBG.png");
-const VORTEX_WHITE_PNG: &[u8] = include_bytes!("../../../public/Vortex_White_NoBG.png");
-// Square transparent sigil-only favicons (500x500). Light = black sigil
-// for light-mode tabs, dark = white sigil for dark-mode tabs. The
-// browser tab switches between them via `prefers-color-scheme` media
-// queries on the `<link rel="icon">` tags in `render::favicon_links`.
-// v2's `public/favicon-*.png` set is unsuitable - those have white
-// backgrounds baked in, so they render as a glaring white square on
-// dark-mode tabs.
-const ICON_LIGHT_PNG: &[u8] = include_bytes!("../../static/icon-light.png");
-const ICON_DARK_PNG: &[u8] = include_bytes!("../../static/icon-dark.png");
-
-/// Cache-busting suffix appended to every static asset URL. Bump on a UI
-/// release so cached browsers see the new bytes.
-pub(crate) const STATIC_ASSET_VERSION: &str = "bench-v3-ui-27";
-
-/// Append the cache-bust query param to a static asset URL.
-pub(crate) fn versioned_asset(path: &str) -> String {
-    format!("{path}?v={STATIC_ASSET_VERSION}")
-}
-
-pub(crate) async fn serve_chart_js() -> impl IntoResponse {
-    static_response(CHART_JS, "application/javascript; charset=utf-8")
-}
-
-pub(crate) async fn serve_chart_zoom_js() -> impl IntoResponse {
-    static_response(CHART_ZOOM_JS, "application/javascript; charset=utf-8")
-}
-
-pub(crate) async fn serve_chart_init_js() -> impl IntoResponse {
-    static_response(CHART_INIT_JS, "application/javascript; charset=utf-8")
-}
-
-pub(crate) async fn serve_style_css() -> impl IntoResponse {
-    static_response(STYLE_CSS, "text/css; charset=utf-8")
-}
-
-pub(crate) async fn serve_vortex_black_png() -> impl IntoResponse {
-    static_response(VORTEX_BLACK_PNG, "image/png")
-}
-
-pub(crate) async fn serve_vortex_white_png() -> impl IntoResponse {
-    static_response(VORTEX_WHITE_PNG, "image/png")
-}
-
-pub(crate) async fn serve_icon_light_png() -> impl IntoResponse {
-    static_response(ICON_LIGHT_PNG, "image/png")
-}
-
-pub(crate) async fn serve_icon_dark_png() -> impl IntoResponse {
-    static_response(ICON_DARK_PNG, "image/png")
-}
-
-fn static_response(bytes: &'static [u8], content_type: &'static str) -> Response {
-    (
-        [
-            (header::CONTENT_TYPE, content_type),
-            (
-                header::CACHE_CONTROL,
-                "no-cache, max-age=0, must-revalidate",
-            ),
-        ],
-        bytes,
-    )
-        .into_response()
-}
diff --git a/benchmarks-website/server/src/html/summary.rs b/benchmarks-website/server/src/html/summary.rs
deleted file mode 100644
index 331cda64064..00000000000
--- a/benchmarks-website/server/src/html/summary.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Group summary card rendering.
-//!
-//! Each [`Summary`] variant renders into a small `.benchmark-scores-summary`
-//! card that lives above the chart grid. Every variant is rendered the same
-//! shape — a list of `.score-item` rows — only the rank label, value, and
-//! footer change.
-
-use maud::Markup;
-use maud::html;
-
-use crate::api::Summary;
-
-/// Render the summary card for a group, or empty markup if `summary` is
-/// `None` or every variant's content list is empty.
-pub(super) fn summary_markup(summary: Option<&Summary>) -> Markup {
-    let Some(summary) = summary else {
-        return html! {};
-    };
-    match summary {
-        Summary::RandomAccess {
-            title,
-            rankings,
-            explanation,
-        } if !rankings.is_empty() => html! {
-            section.benchmark-scores-summary aria-label=(title) {
-                h3.scores-title { (title) }
-                div.scores-list {
-                    @for (idx, item) in rankings.iter().enumerate() {
-                        div.score-item {
-                            span.score-rank { "#" (idx + 1) }
-                            span.score-series title=(item.name) { (item.name) }
-                            span.score-metrics {
-                                span.score-value { (format_time_ns(item.time)) }
-                                span.score-runtime { (format!("{:.2}x", item.ratio)) }
-                            }
-                        }
-                    }
-                }
-                div.scores-explanation { (explanation) }
-            }
-        },
-        Summary::Compression {
-            title,
-            compress_ratio,
-            decompress_ratio,
-            dataset_count: _,
-            explanation,
-        } if compress_ratio.is_some() || decompress_ratio.is_some() => html! {
-            section.benchmark-scores-summary aria-label=(title) {
-                h3.scores-title { (title) }
-                div.scores-list {
-                    @if let Some(v) = compress_ratio {
-                        div.score-item {
-                            span.score-rank { "⚡" }
-                            span.score-series { "Write Speed (Compression)" }
-                            span.score-metrics {
-                                span.score-value { (format!("{v:.2}x")) }
-                            }
-                        }
-                    }
-                    @if let Some(v) = decompress_ratio {
-                        div.score-item {
-                            span.score-rank { "📤" }
-                            span.score-series { "Scan Speed (Decompression)" }
-                            span.score-metrics {
-                                span.score-value { (format!("{v:.2}x")) }
-                            }
-                        }
-                    }
-                }
-                div.scores-explanation { (explanation) }
-            }
-        },
-        Summary::CompressionSize {
-            title,
-            min_ratio,
-            mean_ratio,
-            max_ratio,
-            dataset_count: _,
-            explanation,
-        } => html! {
-            section.benchmark-scores-summary aria-label=(title) {
-                h3.scores-title { (title) }
-                div.scores-list {
-                    div.score-item {
-                        span.score-rank { "⬇️" }
-                        span.score-series { "Min Size Ratio" }
-                        span.score-metrics {
-                            span.score-value { (format!("{min_ratio:.2}x")) }
-                        }
-                    }
-                    div.score-item {
-                        span.score-rank { "📊" }
-                        span.score-series { "Mean Size Ratio" }
-                        span.score-metrics {
-                            span.score-value { (format!("{mean_ratio:.2}x")) }
-                        }
-                    }
-                    div.score-item {
-                        span.score-rank { "⬆️" }
-                        span.score-series { "Max Size Ratio" }
-                        span.score-metrics {
-                            span.score-value { (format!("{max_ratio:.2}x")) }
-                        }
-                    }
-                }
-                div.scores-explanation { (explanation) }
-            }
-        },
-        Summary::QueryBenchmark {
-            title,
-            rankings,
-            explanation,
-        } if !rankings.is_empty() => html! {
-            section.benchmark-scores-summary aria-label=(title) {
-                h3.scores-title { (title) }
-                div.scores-list {
-                    @for (idx, item) in rankings.iter().enumerate() {
-                        div.score-item {
-                            span.score-rank { "#" (idx + 1) }
-                            span.score-series title=(item.name) { (item.name) }
-                            span.score-metrics {
-                                span.score-value { (format!("{:.2}x", item.score)) }
-                                span.score-runtime { (format_time_ns(item.total_runtime)) }
-                            }
-                        }
-                    }
-                }
-                div.scores-explanation { (explanation) }
-            }
-        },
-        _ => html! {},
-    }
-}
-
-fn format_time_ns(ns: f64) -> String {
-    let abs = ns.abs();
-    if abs >= 1_000_000_000.0 {
-        format!("{:.2} s", ns / 1_000_000_000.0)
-    } else if abs >= 1_000_000.0 {
-        format!("{:.2} ms", ns / 1_000_000.0)
-    } else if abs >= 1_000.0 {
-        format!("{:.2} us", ns / 1_000.0)
-    } else {
-        format!("{ns:.0} ns")
-    }
-}
diff --git a/benchmarks-website/server/src/html/toolbar.rs b/benchmarks-website/server/src/html/toolbar.rs
deleted file mode 100644
index 1075632c89b..00000000000
--- a/benchmarks-website/server/src/html/toolbar.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Per-chart toolbar markup: the scope slider + Y-axis switch above each
-//! chart, and the range scrollbar strip below it.
-
-use maud::Markup;
-use maud::html;
-
-/// Render the per-chart toolbar. `idx` namespaces input ids so multiple
-/// charts on the same page don't collide on `<input id="...">`.
-///
-/// All buttons are `<button type="button">` (not `<a>`): this toolbar does
-/// not navigate or rewrite the URL, it manipulates Chart.js state in place.
-pub(super) fn per_chart_toolbar(idx: usize) -> Markup {
-    let slider_id = format!("scope-slider-{idx}");
-    html! {
-        div.toolbar.toolbar--card aria-label="Chart controls" {
-            div.toolbar-group role="group" aria-label="Visible commits" {
-                span.toolbar-label { "Show" }
-                // `max` and `step` are placeholders — `chart-init.js` resets
-                // them after constructing the chart so the slider tracks the
-                // actual loaded commit count, not the initial markup.
-                input id=(slider_id).toolbar-slider type="range"
-                    min="5" max="100" step="1" value="100"
-                    data-role="scope-slider"
-                    aria-label="Custom commit window";
-            }
-            div.toolbar-group role="group" aria-label="Y-axis scale" {
-                span.toolbar-label { "Y" }
-                button.toolbar-btn.toolbar-btn--active type="button" data-y="linear" { "linear" }
-                button.toolbar-btn type="button" data-y="log" { "log" }
-            }
-        }
-    }
-}
-
-/// Render the per-chart range scrollbar strip. A thin track that spans the
-/// full chart width and shows which slice of the fetched commit history is
-/// currently visible. `chart-init.js` hydrates the strip on chart construction
-/// and wires bidirectional drag/resize to the chart's pan/zoom state.
-pub(super) fn range_strip(idx: usize) -> Markup {
-    html! {
-        div.chart-range-strip data-chart-index=(idx)
-            data-role="range-strip"
-            aria-label="Visible commit range"
-            role="slider" {
-            div.chart-range-strip-track {
-                div.chart-range-strip-window data-role="range-window" {
-                    span.chart-range-strip-handle.chart-range-strip-handle--left
-                        data-role="range-handle-left" aria-hidden="true" {}
-                    span.chart-range-strip-handle.chart-range-strip-handle--right
-                        data-role="range-handle-right" aria-hidden="true" {}
-                }
-            }
-        }
-    }
-}
diff --git a/benchmarks-website/server/src/ingest.rs b/benchmarks-website/server/src/ingest.rs
deleted file mode 100644
index f3cd5af57c3..00000000000
--- a/benchmarks-website/server/src/ingest.rs
+++ /dev/null
@@ -1,471 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! `POST /api/ingest` handler.
-//!
-//! Accepts a single [`crate::records::Envelope`] per POST and applies every
-//! record inside one DuckDB transaction. Bearer auth is enforced one layer
-//! up by [`crate::auth::require_bearer`] before the body is read.
-//!
-//! ## HTTP matrix
-//!
-//! | Condition                                                           | Status                                            |
-//! |---------------------------------------------------------------------|---------------------------------------------------|
-//! | Happy path                                                          | 200 with `{ "inserted": N, "updated": M }`        |
-//! | Malformed JSON or unknown field at the envelope level               | 400                                               |
-//! | Unknown `kind`, unknown record field, or per-record validation fail | 400 with the offending record's index             |
-//! | Missing or invalid bearer token                                     | 401 (raised by [`crate::auth::require_bearer`])   |
-//! | Schema version newer than this server expects                      | 409                                               |
-//! | Schema version older than this server expects                       | 400 (via the malformed-envelope path)             |
-//! | Other server error                                                  | 500                                               |
-//!
-//! All-or-nothing semantics: a single failed record fails the whole batch
-//! and the transaction is rolled back. The reported `inserted` and `updated`
-//! counts aggregate across all five fact tables.
-//!
-//! ## measurement_id is server-internal
-//!
-//! Every fact-table row's primary key is computed by
-//! [`crate::db::measurement_id_query`] et al. just before the INSERT and
-//! never crosses a process boundary; emitters do not (and should not) send
-//! one. Re-ingesting the same `(commit_sha, dim tuple)` pair is the upsert
-//! case — `ON CONFLICT (measurement_id) DO UPDATE` overwrites the value
-//! columns and bumps the `updated` counter instead of `inserted`.
-
-use anyhow::Context as _;
-use anyhow::Result;
-use axum::Json;
-use axum::extract::State;
-use axum::response::IntoResponse;
-use duckdb::Connection;
-use duckdb::params;
-use serde::Serialize;
-use serde_json::Value;
-
-use crate::app::AppState;
-use crate::db::measurement_id_compression_size;
-use crate::db::measurement_id_compression_time;
-use crate::db::measurement_id_query;
-use crate::db::measurement_id_random_access;
-use crate::db::measurement_id_vector_search;
-use crate::db::{self};
-use crate::error::IngestError;
-use crate::records::CommitInfo;
-use crate::records::CompressionSize;
-use crate::records::CompressionTime;
-use crate::records::Envelope;
-use crate::records::QueryMeasurement;
-use crate::records::RandomAccessTime;
-use crate::records::Record;
-use crate::records::VectorSearchRun;
-use crate::schema::SCHEMA_VERSION;
-
-// Unless we start merging 128 PR every second we are not hitting this max.
-const WRITE_CONFLICT_ATTEMPTS: usize = 128;
-
-/// Successful ingest response body.
-#[derive(Debug, Serialize)]
-pub struct IngestResponse {
-    /// Rows inserted across all five fact tables in this transaction.
-    pub inserted: u64,
-    /// Rows that hit `ON CONFLICT (measurement_id) DO UPDATE`.
-    pub updated: u64,
-}
-
-/// Handler for `POST /api/ingest`. Bearer auth is enforced by the
-/// [`crate::auth::require_bearer`] middleware, not here.
-pub async fn handle(
-    State(state): State<AppState>,
-    body: Json<Value>,
-) -> Result<impl IntoResponse, IngestError> {
-    let Json(value) = body;
-    let envelope: Envelope =
-        serde_json::from_value(value).map_err(|e| IngestError::Malformed(e.to_string()))?;
-    validate_envelope(&envelope)?;
-
-    let response = db::run_blocking(&state.db, move |conn| apply_envelope(conn, envelope))
-        .await
-        .map_err(|err| match err.downcast::<IngestError>() {
-            Ok(ingest) => ingest,
-            Err(other) => IngestError::Internal(other),
-        })?;
-    // Fallback read endpoints serve from `state.cache`; the materialized
-    // website hot path serves from `state.read_store`. Keep the old
-    // generation live while a background rebuild warms the next one.
-    state.cache.invalidate();
-    state.read_store.schedule_rebuild(state.db.clone()).await;
-    Ok(Json(response))
-}
-
-fn validate_envelope(env: &Envelope) -> Result<(), IngestError> {
-    if env.run_meta.schema_version > SCHEMA_VERSION {
-        return Err(IngestError::SchemaVersionTooNew {
-            expected: SCHEMA_VERSION,
-            got: env.run_meta.schema_version,
-        });
-    }
-    if env.run_meta.schema_version < SCHEMA_VERSION {
-        return Err(IngestError::Malformed(format!(
-            "schema_version {} is older than server's {}",
-            env.run_meta.schema_version, SCHEMA_VERSION
-        )));
-    }
-    Ok(())
-}
-
-fn retry_write_conflicts<F, T>(mut op: F) -> Result<T>
-where
-    F: FnMut() -> Result<T>,
-{
-    for attempt in 1..=WRITE_CONFLICT_ATTEMPTS {
-        match op() {
-            Ok(value) => return Ok(value),
-            Err(err) if attempt < WRITE_CONFLICT_ATTEMPTS && is_retryable_write_conflict(&err) => {
-                std::thread::yield_now();
-            }
-            Err(err) => return Err(err),
-        }
-    }
-    unreachable!("loop either returns a value or the final error")
-}
-
-fn is_retryable_write_conflict(err: &anyhow::Error) -> bool {
-    err.chain().any(|cause| {
-        let message = cause.to_string().to_ascii_lowercase();
-        message.contains("conflict")
-            && (message.contains("transaction")
-                || message.contains("write")
-                || message.contains("tuple")
-                || message.contains("update"))
-    })
-}
-
-fn apply_envelope(conn: &mut Connection, env: Envelope) -> Result<IngestResponse> {
-    retry_write_conflicts(|| apply_envelope_once(conn, &env))
-}
-
-fn apply_envelope_once(conn: &mut Connection, env: &Envelope) -> Result<IngestResponse> {
-    let tx = conn.transaction().context("begin transaction")?;
-
-    upsert_commit(&tx, &env.commit).context("upsert commit")?;
-
-    let mut inserted = 0u64;
-    let mut updated = 0u64;
-    for (idx, record) in env.records.iter().enumerate() {
-        if record.commit_sha() != env.commit.sha {
-            return Err(IngestError::Record {
-                index: idx,
-                message: format!(
-                    "record commit_sha {:?} does not match envelope commit.sha {:?}",
-                    record.commit_sha(),
-                    env.commit.sha,
-                ),
-            }
-            .into());
-        }
-        match apply_record(&tx, record) {
-            Ok(was_update) => {
-                if was_update {
-                    updated += 1;
-                } else {
-                    inserted += 1;
-                }
-            }
-            Err(RecordError::Validation(msg)) => {
-                return Err(IngestError::Record {
-                    index: idx,
-                    message: msg,
-                }
-                .into());
-            }
-            Err(RecordError::Internal(err)) => {
-                return Err(err.context(format!("applying record at index {idx}")));
-            }
-        }
-    }
-
-    tx.commit().context("commit transaction")?;
-
-    Ok(IngestResponse { inserted, updated })
-}
-
-fn upsert_commit(tx: &duckdb::Transaction<'_>, c: &CommitInfo) -> Result<()> {
-    tx.execute(
-        r#"
-        INSERT INTO commits (
-            commit_sha, timestamp, message, author_name, author_email,
-            committer_name, committer_email, tree_sha, url
-        ) VALUES (?, CAST(? AS TIMESTAMPTZ), ?, ?, ?, ?, ?, ?, ?)
-        ON CONFLICT (commit_sha) DO UPDATE SET
-            timestamp       = excluded.timestamp,
-            message         = excluded.message,
-            author_name     = excluded.author_name,
-            author_email    = excluded.author_email,
-            committer_name  = excluded.committer_name,
-            committer_email = excluded.committer_email,
-            tree_sha        = excluded.tree_sha,
-            url             = excluded.url
-        "#,
-        params![
-            c.sha,
-            c.timestamp,
-            c.message,
-            c.author_name,
-            c.author_email,
-            c.committer_name,
-            c.committer_email,
-            c.tree_sha,
-            c.url,
-        ],
-    )?;
-    Ok(())
-}
-
-/// Per-record error split: validation failures carry a message that the
-/// caller turns into an [`IngestError::Record`] with the right index;
-/// anything else bubbles up as a 500.
-pub(crate) enum RecordError {
-    Validation(String),
-    Internal(anyhow::Error),
-}
-
-impl From<anyhow::Error> for RecordError {
-    fn from(err: anyhow::Error) -> Self {
-        Self::Internal(err)
-    }
-}
-
-impl From<duckdb::Error> for RecordError {
-    fn from(err: duckdb::Error) -> Self {
-        Self::Internal(err.into())
-    }
-}
-
-fn apply_record(tx: &duckdb::Transaction<'_>, record: &Record) -> Result<bool, RecordError> {
-    (crate::family::family_for_record(record).apply_record)(tx, record)
-}
-
-pub(crate) fn insert_query_measurement(
-    tx: &duckdb::Transaction<'_>,
-    r: &QueryMeasurement,
-) -> Result<bool, RecordError> {
-    if !matches!(r.storage.as_str(), "nvme" | "s3") {
-        return Err(RecordError::Validation(format!(
-            "storage must be 'nvme' or 's3', got {:?}",
-            r.storage
-        )));
-    }
-    if !memory_quartet_consistent(r) {
-        return Err(RecordError::Validation(
-            "memory fields must be populated together (all four or none)".into(),
-        ));
-    }
-    let mid = measurement_id_query(r);
-    let was_update = exists(tx, "query_measurements", mid)?;
-    tx.execute(
-        r#"
-        INSERT INTO query_measurements (
-            measurement_id, commit_sha, dataset, dataset_variant, scale_factor,
-            query_idx, storage, engine, format,
-            value_ns, all_runtimes_ns,
-            peak_physical, peak_virtual, physical_delta, virtual_delta,
-            env_triple
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CAST(? AS BIGINT[]), ?, ?, ?, ?, ?)
-        ON CONFLICT (measurement_id) DO UPDATE SET
-            commit_sha      = excluded.commit_sha,
-            value_ns        = excluded.value_ns,
-            all_runtimes_ns = excluded.all_runtimes_ns,
-            peak_physical   = excluded.peak_physical,
-            peak_virtual    = excluded.peak_virtual,
-            physical_delta  = excluded.physical_delta,
-            virtual_delta   = excluded.virtual_delta,
-            env_triple      = excluded.env_triple
-        "#,
-        params![
-            mid,
-            r.commit_sha,
-            r.dataset,
-            r.dataset_variant,
-            r.scale_factor,
-            r.query_idx,
-            r.storage,
-            r.engine,
-            r.format,
-            r.value_ns,
-            runtimes_literal(&r.all_runtimes_ns),
-            r.peak_physical,
-            r.peak_virtual,
-            r.physical_delta,
-            r.virtual_delta,
-            r.env_triple,
-        ],
-    )?;
-    Ok(was_update)
-}
-
-pub(crate) fn insert_compression_time(
-    tx: &duckdb::Transaction<'_>,
-    r: &CompressionTime,
-) -> Result<bool, RecordError> {
-    let mid = measurement_id_compression_time(r);
-    let was_update = exists(tx, "compression_times", mid)?;
-    tx.execute(
-        r#"
-        INSERT INTO compression_times (
-            measurement_id, commit_sha, dataset, dataset_variant,
-            format, op, value_ns, all_runtimes_ns, env_triple
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, CAST(? AS BIGINT[]), ?)
-        ON CONFLICT (measurement_id) DO UPDATE SET
-            commit_sha      = excluded.commit_sha,
-            value_ns        = excluded.value_ns,
-            all_runtimes_ns = excluded.all_runtimes_ns,
-            env_triple      = excluded.env_triple
-        "#,
-        params![
-            mid,
-            r.commit_sha,
-            r.dataset,
-            r.dataset_variant,
-            r.format,
-            r.op,
-            r.value_ns,
-            runtimes_literal(&r.all_runtimes_ns),
-            r.env_triple,
-        ],
-    )?;
-    Ok(was_update)
-}
-
-pub(crate) fn insert_compression_size(
-    tx: &duckdb::Transaction<'_>,
-    r: &CompressionSize,
-) -> Result<bool, RecordError> {
-    let mid = measurement_id_compression_size(r);
-    let was_update = exists(tx, "compression_sizes", mid)?;
-    tx.execute(
-        r#"
-        INSERT INTO compression_sizes (
-            measurement_id, commit_sha, dataset, dataset_variant,
-            format, value_bytes
-        ) VALUES (?, ?, ?, ?, ?, ?)
-        ON CONFLICT (measurement_id) DO UPDATE SET
-            commit_sha   = excluded.commit_sha,
-            value_bytes  = excluded.value_bytes
-        "#,
-        params![
-            mid,
-            r.commit_sha,
-            r.dataset,
-            r.dataset_variant,
-            r.format,
-            r.value_bytes,
-        ],
-    )?;
-    Ok(was_update)
-}
-
-pub(crate) fn insert_random_access(
-    tx: &duckdb::Transaction<'_>,
-    r: &RandomAccessTime,
-) -> Result<bool, RecordError> {
-    let mid = measurement_id_random_access(r);
-    let was_update = exists(tx, "random_access_times", mid)?;
-    tx.execute(
-        r#"
-        INSERT INTO random_access_times (
-            measurement_id, commit_sha, dataset, format,
-            value_ns, all_runtimes_ns, env_triple
-        ) VALUES (?, ?, ?, ?, ?, CAST(? AS BIGINT[]), ?)
-        ON CONFLICT (measurement_id) DO UPDATE SET
-            commit_sha      = excluded.commit_sha,
-            value_ns        = excluded.value_ns,
-            all_runtimes_ns = excluded.all_runtimes_ns,
-            env_triple      = excluded.env_triple
-        "#,
-        params![
-            mid,
-            r.commit_sha,
-            r.dataset,
-            r.format,
-            r.value_ns,
-            runtimes_literal(&r.all_runtimes_ns),
-            r.env_triple,
-        ],
-    )?;
-    Ok(was_update)
-}
-
-pub(crate) fn insert_vector_search(
-    tx: &duckdb::Transaction<'_>,
-    r: &VectorSearchRun,
-) -> Result<bool, RecordError> {
-    let mid = measurement_id_vector_search(r);
-    let was_update = exists(tx, "vector_search_runs", mid)?;
-    tx.execute(
-        r#"
-        INSERT INTO vector_search_runs (
-            measurement_id, commit_sha, dataset, layout, flavor, threshold,
-            value_ns, all_runtimes_ns, matches, rows_scanned, bytes_scanned,
-            iterations, env_triple
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, CAST(? AS BIGINT[]), ?, ?, ?, ?, ?)
-        ON CONFLICT (measurement_id) DO UPDATE SET
-            commit_sha      = excluded.commit_sha,
-            value_ns        = excluded.value_ns,
-            all_runtimes_ns = excluded.all_runtimes_ns,
-            matches         = excluded.matches,
-            rows_scanned    = excluded.rows_scanned,
-            bytes_scanned   = excluded.bytes_scanned,
-            iterations      = excluded.iterations,
-            env_triple      = excluded.env_triple
-        "#,
-        params![
-            mid,
-            r.commit_sha,
-            r.dataset,
-            r.layout,
-            r.flavor,
-            r.threshold,
-            r.value_ns,
-            runtimes_literal(&r.all_runtimes_ns),
-            r.matches,
-            r.rows_scanned,
-            r.bytes_scanned,
-            r.iterations,
-            r.env_triple,
-        ],
-    )?;
-    Ok(was_update)
-}
-
-fn exists(tx: &duckdb::Transaction<'_>, table: &str, mid: i64) -> Result<bool, RecordError> {
-    // Table name is from a closed enum of literals above, never user input.
-    let sql = format!("SELECT 1 FROM {table} WHERE measurement_id = ? LIMIT 1");
-    let mut stmt = tx.prepare(&sql)?;
-    let exists = stmt.exists(params![mid])?;
-    Ok(exists)
-}
-
-fn runtimes_literal(values: &[i64]) -> String {
-    let mut s = String::with_capacity(values.len() * 8 + 2);
-    s.push('[');
-    for (i, v) in values.iter().enumerate() {
-        if i > 0 {
-            s.push(',');
-        }
-        s.push_str(&v.to_string());
-    }
-    s.push(']');
-    s
-}
-
-fn memory_quartet_consistent(r: &QueryMeasurement) -> bool {
-    let any = r.peak_physical.is_some()
-        || r.peak_virtual.is_some()
-        || r.physical_delta.is_some()
-        || r.virtual_delta.is_some();
-    let all = r.peak_physical.is_some()
-        && r.peak_virtual.is_some()
-        && r.physical_delta.is_some()
-        && r.virtual_delta.is_some();
-    !any || all
-}
diff --git a/benchmarks-website/server/src/lib.rs b/benchmarks-website/server/src/lib.rs
deleted file mode 100644
index 42c63dacb6d..00000000000
--- a/benchmarks-website/server/src/lib.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! `vortex-bench-server` - the v3 [`bench.vortex.dev`](https://bench.vortex.dev)
-//! server.
-//!
-//! A single Rust binary that owns one DuckDB file on local disk, accepts
-//! bearer-authenticated `/api/ingest` POSTs, and serves the JSON read API
-//! plus every HTML page. All static assets (Chart.js + the zoom plugin +
-//! `chart-init.js` + `style.css` + the two logos) are baked into the
-//! binary via `include_bytes!` so a deploy is one binary plus a database
-//! file.
-//!
-//! The hot website path is a materialized latest-100 read model. DuckDB
-//! remains the source of truth, but default group/chart hydration is served
-//! from precomputed, precompressed in-memory artifacts. See
-//! `benchmarks-website/server/ARCHITECTURE.md` for the higher-level model.
-//!
-//! ## Routes
-//!
-//! - `GET /` - landing page, every group rendered as chart shells plus
-//!   versioned shard metadata. Groups hydrate on intent/open.
-//! - `GET /chart/{slug}` - single-chart permalink. Defaults to the
-//!   materialized latest-100 window; `?n=all` uses the DB fallback.
-//! - `GET /group/{slug}` - every chart shell in one group on a single page,
-//!   opened by default and hydrated through the shard path.
-//! - `GET /static/...` - the bundled JS / CSS / logos.
-//! - `GET /api/groups` - flat list of every group with chart-link metadata.
-//!   Defaults to a materialized artifact.
-//! - `GET /api/chart/{slug}` - one chart's payload (`history`, `commits`,
-//!   `series`, `unit_kind`, ...). Defaults to a materialized latest-100
-//!   artifact; `?n=all` and non-default windows use the DB fallback.
-//! - `GET /api/group/{slug}` - every chart in one group. Defaults to a
-//!   materialized latest-100 compatibility artifact.
-//! - `GET /api/artifacts/{generation}/groups/{group_slug}/shards/{index}` -
-//!   immutable versioned latest-100 group shard artifact for page hydration.
-//! - `GET /health` - liveness probe + per-table row counts.
-//! - `POST /api/ingest` - bearer-gated ingest. See [`ingest`] for the HTTP
-//!   matrix and [`auth`] for the bearer middleware.
-//! - `POST /api/admin/snapshot`, `POST /api/admin/sql` - admin-bearer-gated
-//!   snapshot trigger and read-only SQL. Mounted only when
-//!   [`app::AppState::with_admin`] has been called. See [`admin`].
-//!
-//! ## Module map
-//!
-//! | Module        | Role                                                                                        |
-//! |---------------|---------------------------------------------------------------------------------------------|
-//! | [`app`]       | [`app::AppState`] (DB handle + bearer + read store + paths) and the Axum router composition. |
-//! | [`auth`]      | Bearer-token middleware for `/api/ingest`.                                                  |
-//! | [`admin`]     | `/api/admin/*` handlers + admin-bearer middleware. See `ops/README.md` for the operator flow. |
-//! | [`db`]        | [`db::DbHandle`] task-local connection cloning + the per-fact-table `measurement_id_*` hash functions. |
-//! | [`schema`]    | DuckDB DDL ([`schema::COMMITS_DDL`] + per-family DDL constants) and the wire schema version.|
-//! | [`records`]   | Wire shapes for `POST /api/ingest`.                                                         |
-//! | [`family`]    | Per-fact-table [`family::Family`] registry tying together table name, slug prefixes, `measurement_id_*`, `apply_record`, and the read-API collectors. |
-//! | [`ingest`]    | `POST /api/ingest` handler, cache invalidation, and read-model rebuild scheduling.          |
-//! | [`error`]     | [`error::IngestError`] and [`error::ApiError`] with their HTTP-status mapping.              |
-//! | [`slug`]      | [`slug::ChartKey`] / [`slug::GroupKey`] enums + base64url round-trip.                       |
-//! | [`api`]       | Read API. `mod.rs` mounts the handlers; submodules are listed on its module doc.            |
-//! | [`html`]      | HTML pages - `mod.rs` mounts the routes; submodules render the body.                        |
-//! | [`read_model`]| Materialized latest-100 generations and encoded artifact serving.                           |
-//! | [`query_cache`]| Single-flight cache for non-materialized fallback reads.                                    |
-//!
-//! ## Request flow
-//!
-//! 1. Axum receives the request and routes by method + path.
-//! 2. `/api/ingest` first passes through [`auth::require_bearer`]; other
-//!    routes skip auth.
-//! 3. The handler parses body / path / query into typed inputs (e.g.
-//!    [`slug::ChartKey::from_slug`]).
-//! 4. For default latest-100 API reads, the handler serves an encoded
-//!    [`read_model`] artifact directly from memory.
-//! 5. For ingest, `?n=all`, and non-default windows, the handler hands a
-//!    closure to [`db::run_blocking`], which clones a task-local DuckDB
-//!    connection and runs synchronous work on `tokio::task::spawn_blocking`.
-//! 6. Fallback chart/group reads go through [`query_cache`] so concurrent
-//!    identical misses share one compute.
-//! 7. Errors are mapped into [`error::IngestError`] / [`error::ApiError`]
-//!    with the right HTTP status. HTML responses are rendered via `maud`;
-//!    hot JSON artifacts are returned as already encoded bytes.
-
-pub mod admin;
-pub mod api;
-pub mod app;
-pub mod auth;
-pub mod db;
-pub mod error;
-pub mod family;
-pub mod html;
-pub mod ingest;
-pub mod query_cache;
-pub mod read_model;
-pub mod records;
-pub mod schema;
-pub mod slug;
diff --git a/benchmarks-website/server/src/main.rs b/benchmarks-website/server/src/main.rs
deleted file mode 100644
index c232b0c2fa7..00000000000
--- a/benchmarks-website/server/src/main.rs
+++ /dev/null
@@ -1,357 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Binary entrypoint for `vortex-bench-server`.
-//!
-//! Reads the following environment variables before constructing the two
-//! routers it serves ([`vortex_bench_server::app::public_router`] and,
-//! when `ADMIN_BEARER_TOKEN` is set, [`vortex_bench_server::app::admin_router`]):
-//!
-//! - `INGEST_BEARER_TOKEN` - required and non-empty. Token presented by ingest clients
-//!   on `Authorization: Bearer <token>`. Compared in constant time.
-//! - `ADMIN_BEARER_TOKEN` - optional. When set to a non-empty value, mounts the
-//!   `/api/admin/snapshot` and `/api/admin/sql` endpoints; both expect
-//!   this token in the `Authorization: Bearer …` header. Without it the
-//!   admin router is not mounted at all (404). The `INGEST_BEARER_TOKEN`
-//!   does not work on admin routes - keep them separate so they rotate
-//!   independently.
-//! - `VORTEX_BENCH_DB` - DuckDB file path. Default: `bench.duckdb` in the
-//!   working directory.
-//! - `VORTEX_BENCH_SNAPSHOT_DIR` - directory `/api/admin/snapshot` writes
-//!   per-table Vortex snapshots into (`schema.sql` plus one
-//!   `<table>.vortex` file per table). Default:
-//!   `<VORTEX_BENCH_DB parent>/snapshots`.
-//! - `VORTEX_BENCH_EXTENSION_DIR` - directory DuckDB installs extensions
-//!   into. Default: `<VORTEX_BENCH_DB parent>/duckdb-extensions`. The
-//!   default lives under `STATE_DIR`, which the systemd unit makes
-//!   writable; this is what lets `INSTALL vortex` succeed under
-//!   `ProtectHome=read-only`.
-//! - `VORTEX_BENCH_BIND` - `host:port` the **public** listener binds to.
-//!   Highest priority. Default `127.0.0.1:3000` (after `PORT` fallback).
-//!   Override to `0.0.0.0:3000` for container deploys. Only ingest, read,
-//!   HTML, and `/health` are served here - admin routes do not match.
-//! - `PORT` - optional PaaS-conventional knob for the **public** listener
-//!   only. When set and `VORTEX_BENCH_BIND` is not, the public listener
-//!   binds `0.0.0.0:$PORT`. Does not affect the admin listener.
-//! - `VORTEX_BENCH_ADMIN_BIND` - `host:port` the **admin** listener binds
-//!   to when `ADMIN_BEARER_TOKEN` is set. Default `127.0.0.1:3001`. The
-//!   address MUST resolve to a loopback IP (`127.0.0.0/8` or `::1`); the
-//!   server refuses to start otherwise. This is the load-bearing guarantee
-//!   that `/api/admin/*` never reaches the public network even when
-//!   `VORTEX_BENCH_BIND=0.0.0.0:3000`. Must also resolve to a different
-//!   address than the public bind.
-//! - `VORTEX_BENCH_LOG` - `tracing-subscriber` env filter spec. Default
-//!   `info`.
-//!
-//! On Unix, SIGTERM and SIGINT both trigger a graceful drain - in-flight
-//! requests are allowed to finish before the process exits. systemd's
-//! `TimeoutStopSec` (default 90s) bounds the grace window, which matters
-//! because `systemctl restart` is what the deploy timer fires on every
-//! new binary roll. On non-Unix targets only Ctrl-C/SIGINT is wired.
-
-use std::env;
-use std::net::SocketAddr;
-use std::path::PathBuf;
-
-use anyhow::Context as _;
-use anyhow::Result;
-use anyhow::anyhow;
-use futures::FutureExt;
-use tokio::net::TcpListener;
-use tracing_subscriber::EnvFilter;
-
-#[tokio::main]
-async fn main() -> Result<()> {
-    tracing_subscriber::fmt()
-        .with_env_filter(
-            EnvFilter::try_from_env("VORTEX_BENCH_LOG").unwrap_or_else(|_| EnvFilter::new("info")),
-        )
-        .init();
-
-    let db_path: PathBuf = env::var("VORTEX_BENCH_DB")
-        .unwrap_or_else(|_| "bench.duckdb".to_string())
-        .into();
-    let bearer_token =
-        env::var("INGEST_BEARER_TOKEN").context("INGEST_BEARER_TOKEN env var must be set")?;
-    let admin_bearer_token = env::var("ADMIN_BEARER_TOKEN")
-        .ok()
-        .filter(|token| !token.trim().is_empty());
-    // `VORTEX_BENCH_BIND` wins (full `host:port`). If unset, fall back to the
-    // PaaS-conventional `PORT` env var (binds to `0.0.0.0:$PORT`). Otherwise
-    // localhost-only on the default port. `PORT` only affects the public
-    // listener - the admin listener has its own env var below.
-    let public_bind = env::var("VORTEX_BENCH_BIND")
-        .ok()
-        .or_else(|| env::var("PORT").ok().map(|p| format!("0.0.0.0:{p}")))
-        .unwrap_or_else(|| "127.0.0.1:3000".to_string());
-    let admin_bind =
-        env::var("VORTEX_BENCH_ADMIN_BIND").unwrap_or_else(|_| "127.0.0.1:3001".to_string());
-
-    let mut state = vortex_bench_server::app::AppState::open(&db_path, bearer_token)
-        .with_context(|| format!("opening DuckDB at {}", db_path.display()))?;
-    if let Some(token) = admin_bearer_token {
-        state = state.with_admin(token);
-    } else {
-        tracing::warn!(
-            "ADMIN_BEARER_TOKEN is unset or empty - /api/admin/* will return 404 \
-            (snapshot + read-only SQL disabled)"
-        );
-    }
-    if let Ok(dir) = env::var("VORTEX_BENCH_SNAPSHOT_DIR") {
-        state = state.with_snapshot_dir(PathBuf::from(dir));
-    }
-    if let Ok(dir) = env::var("VORTEX_BENCH_EXTENSION_DIR") {
-        state = state
-            .with_extension_dir(PathBuf::from(dir))
-            .context("applying VORTEX_BENCH_EXTENSION_DIR")?;
-    }
-    let snapshot_dir = state.snapshot_dir.clone();
-    let extension_dir = state.extension_dir.clone();
-    let admin_app = vortex_bench_server::app::admin_router(state.clone());
-    let public_app = vortex_bench_server::app::public_router(state);
-
-    // Resolve and validate BOTH addresses before opening any listening
-    // socket. The earlier order opened the admin socket and only THEN
-    // checked the resolved address was loopback, which briefly bound a
-    // potentially-public address to the kernel's SYN queue before the
-    // refusal. Resolve via `tokio::net::lookup_host` (DNS-aware, matches
-    // what `TcpListener::bind` would use) and run both checks against the
-    // resolved `SocketAddr` first.
-    let public_addr = resolve_first_addr(&public_bind)
-        .await
-        .with_context(|| format!("resolving public listener bind {public_bind:?}"))?;
-    let admin_addr_opt = match admin_app.as_ref() {
-        Some(_) => Some(
-            resolve_first_addr(&admin_bind)
-                .await
-                .with_context(|| format!("resolving admin listener bind {admin_bind:?}"))?,
-        ),
-        None => None,
-    };
-    if let Some(admin_addr) = admin_addr_opt {
-        ensure_admin_is_loopback(&admin_bind, admin_addr)?;
-        ensure_distinct_binds(public_addr, admin_addr)?;
-    }
-
-    let public_listener = TcpListener::bind(public_addr)
-        .await
-        .with_context(|| format!("binding public listener to {public_addr}"))?;
-    let public_addr = public_listener.local_addr()?;
-
-    let admin_listener = match (admin_app.as_ref(), admin_addr_opt) {
-        (Some(_), Some(admin_addr)) => {
-            let listener = TcpListener::bind(admin_addr)
-                .await
-                .with_context(|| format!("binding admin listener to {admin_addr}"))?;
-            let admin_addr = listener.local_addr()?;
-            // Defense-in-depth re-check on the post-bind address (a hostname
-            // resolution that drifted between our resolve and bind would be
-            // surprising; surface it rather than silently expose the port).
-            ensure_admin_is_loopback(&admin_bind, admin_addr)?;
-            Some((listener, admin_addr))
-        }
-        _ => None,
-    };
-
-    tracing::info!(
-        public_addr = %public_addr,
-        admin_addr = ?admin_listener.as_ref().map(|(_, a)| *a),
-        db = %db_path.display(),
-        snapshot_dir = %snapshot_dir.display(),
-        extension_dir = %extension_dir.display(),
-        "bench server listening"
-    );
-
-    // Both listeners share one shutdown trigger so a single SIGTERM drains
-    // ingest, admin, and HTML in lockstep. `Shared` lets us hand the same
-    // future to each `with_graceful_shutdown`.
-    let shutdown = shutdown_signal().shared();
-    match (admin_app, admin_listener) {
-        (Some(admin_app), Some((admin_listener, _))) => {
-            let public_fut =
-                axum::serve(public_listener, public_app).with_graceful_shutdown(shutdown.clone());
-            let admin_fut = axum::serve(admin_listener, admin_app).with_graceful_shutdown(shutdown);
-            tokio::try_join!(public_fut, admin_fut)?;
-        }
-        _ => {
-            axum::serve(public_listener, public_app)
-                .with_graceful_shutdown(shutdown)
-                .await?;
-        }
-    }
-    Ok(())
-}
-
-/// Resolve a `host:port` spec to its first reachable [`SocketAddr`].
-async fn resolve_first_addr(spec: &str) -> Result<SocketAddr> {
-    tokio::net::lookup_host(spec)
-        .await
-        .with_context(|| format!("looking up {spec:?}"))?
-        .next()
-        .ok_or_else(|| anyhow!("{spec:?} did not resolve to any address"))
-}
-
-/// Refuse to start if the public and admin listeners would land on the
-/// same port. The admin listener exists specifically to keep
-/// `/api/admin/*` off the public network, so the two collapsing back into
-/// one is a silent rollback of that guarantee.
-///
-/// Equality-of-`SocketAddr` alone misses the case where the public bind
-/// is `0.0.0.0:3000` and the admin bind is `127.0.0.1:3000` (or any other
-/// loopback + same port). The OS would EADDRINUSE at bind time, but the
-/// error message ("Address already in use") gives no hint that
-/// `VORTEX_BENCH_ADMIN_BIND` is the thing to change. Catch it here with
-/// an actionable diagnostic instead.
-fn ensure_distinct_binds(public: SocketAddr, admin: SocketAddr) -> Result<()> {
-    let port_collision = public.port() == admin.port()
-        && (public.ip() == admin.ip()
-            || public.ip().is_unspecified()
-            || admin.ip().is_unspecified());
-    if port_collision {
-        return Err(anyhow!(
-            "public bind {public} and admin bind {admin} would overlap on port \
-             {}; keep VORTEX_BENCH_ADMIN_BIND on a port distinct from the public listener",
-            public.port()
-        ));
-    }
-    Ok(())
-}
-
-/// Refuse to start if the admin listener resolved to a non-loopback
-/// address. Without this guard, `VORTEX_BENCH_ADMIN_BIND=0.0.0.0:3001`
-/// (or any public IP / unspecified address / non-loopback hostname)
-/// would silently expose `/api/admin/*` - the bearer-gated SQL and
-/// snapshot endpoints - to the public network. The contract is that the
-/// admin listener is loopback-only and the only way callers reach it is
-/// from the same host. An operator who genuinely wants remote admin
-/// access should put it behind an SSH tunnel rather than opening the
-/// bind, so this check is intentionally strict.
-fn ensure_admin_is_loopback(spec: &str, admin: SocketAddr) -> Result<()> {
-    if !admin.ip().is_loopback() {
-        return Err(anyhow!(
-            "admin listener resolved to {admin} (from VORTEX_BENCH_ADMIN_BIND={spec:?}); \
-             /api/admin/* must remain loopback-only. Use 127.0.0.1, ::1, or \
-             a hostname that resolves to a loopback address; reach admin from \
-             elsewhere via an SSH tunnel"
-        ));
-    }
-    Ok(())
-}
-
-/// Resolves when the process receives SIGINT or SIGTERM. Used as the
-/// graceful-shutdown future for `axum::serve` so a `systemctl restart`
-/// (SIGTERM) lets in-flight requests finish before the process exits.
-/// `systemd`'s `TimeoutStopSec` (default 90s) bounds the grace window -
-/// nothing inside the process imposes its own timeout.
-async fn shutdown_signal() {
-    let ctrl_c = async {
-        tokio::signal::ctrl_c()
-            .await
-            .expect("install ctrl_c handler");
-    };
-    #[cfg(unix)]
-    let terminate = async {
-        tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
-            .expect("install SIGTERM handler")
-            .recv()
-            .await;
-    };
-    #[cfg(not(unix))]
-    let terminate = std::future::pending::<()>();
-
-    tokio::select! {
-        _ = ctrl_c => tracing::info!("received SIGINT - shutting down"),
-        _ = terminate => tracing::info!("received SIGTERM - shutting down"),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::net::SocketAddr;
-
-    use super::ensure_admin_is_loopback;
-    use super::ensure_distinct_binds;
-
-    #[test]
-    fn admin_loopback_v4_passes() {
-        let addr: SocketAddr = "127.0.0.1:3001".parse().unwrap();
-        ensure_admin_is_loopback("127.0.0.1:3001", addr).expect("127.0.0.1 is loopback");
-    }
-
-    #[test]
-    fn admin_loopback_v6_passes() {
-        let addr: SocketAddr = "[::1]:3001".parse().unwrap();
-        ensure_admin_is_loopback("[::1]:3001", addr).expect("::1 is loopback");
-    }
-
-    #[test]
-    fn admin_loopback_127_8_subnet_passes() {
-        // The entire 127.0.0.0/8 block is loopback.
-        let addr: SocketAddr = "127.1.2.3:3001".parse().unwrap();
-        ensure_admin_is_loopback("127.1.2.3:3001", addr).expect("127.0.0.0/8 is loopback");
-    }
-
-    #[test]
-    fn admin_zero_v4_rejected() {
-        let addr: SocketAddr = "0.0.0.0:3001".parse().unwrap();
-        let err = ensure_admin_is_loopback("0.0.0.0:3001", addr)
-            .expect_err("0.0.0.0 must be rejected as non-loopback");
-        let msg = err.to_string();
-        assert!(msg.contains("loopback-only"), "{msg}");
-    }
-
-    #[test]
-    fn admin_zero_v6_rejected() {
-        let addr: SocketAddr = "[::]:3001".parse().unwrap();
-        ensure_admin_is_loopback("[::]:3001", addr)
-            .expect_err(":: must be rejected as non-loopback");
-    }
-
-    #[test]
-    fn admin_public_ip_rejected() {
-        let addr: SocketAddr = "10.0.0.5:3001".parse().unwrap();
-        ensure_admin_is_loopback("10.0.0.5:3001", addr)
-            .expect_err("private/public IP must be rejected as non-loopback");
-    }
-
-    #[test]
-    fn distinct_binds_passes() {
-        let p: SocketAddr = "127.0.0.1:3000".parse().unwrap();
-        let a: SocketAddr = "127.0.0.1:3001".parse().unwrap();
-        ensure_distinct_binds(p, a).expect("different ports are distinct");
-    }
-
-    #[test]
-    fn same_bind_rejected() {
-        let p: SocketAddr = "127.0.0.1:3000".parse().unwrap();
-        let a: SocketAddr = "127.0.0.1:3000".parse().unwrap();
-        ensure_distinct_binds(p, a).expect_err("identical binds must be rejected");
-    }
-
-    #[test]
-    fn unspecified_v4_collides_with_loopback_same_port() {
-        // The motivating case for the cycle-1 ensure_distinct_binds fix:
-        // public on 0.0.0.0:3000 + admin on 127.0.0.1:3000 would silently
-        // bind to overlapping ports; the OS would EADDRINUSE at bind time
-        // with no actionable diagnostic. Catch it pre-bind.
-        let p: SocketAddr = "0.0.0.0:3000".parse().unwrap();
-        let a: SocketAddr = "127.0.0.1:3000".parse().unwrap();
-        ensure_distinct_binds(p, a)
-            .expect_err("0.0.0.0:3000 + 127.0.0.1:3000 must be rejected as a port-collision");
-    }
-
-    #[test]
-    fn unspecified_v4_different_port_from_loopback_passes() {
-        let p: SocketAddr = "0.0.0.0:3000".parse().unwrap();
-        let a: SocketAddr = "127.0.0.1:3001".parse().unwrap();
-        ensure_distinct_binds(p, a).expect("distinct ports must not be rejected");
-    }
-
-    #[test]
-    fn unspecified_v6_collides_with_v6_loopback_same_port() {
-        let p: SocketAddr = "[::]:3000".parse().unwrap();
-        let a: SocketAddr = "[::1]:3000".parse().unwrap();
-        ensure_distinct_binds(p, a)
-            .expect_err("[::]:3000 + [::1]:3000 must be rejected as a port-collision");
-    }
-}
diff --git a/benchmarks-website/server/src/query_cache.rs b/benchmarks-website/server/src/query_cache.rs
deleted file mode 100644
index 3647ab920ec..00000000000
--- a/benchmarks-website/server/src/query_cache.rs
+++ /dev/null
@@ -1,472 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! In-memory query result cache for the read API.
-//!
-//! Every chart payload, group discovery result, and filter universe in the v3
-//! site is a deterministic function of the DuckDB snapshot — and that
-//! snapshot only changes when `/api/ingest` lands a new envelope (~30 times a
-//! day). Without a cache, every concurrent request re-runs the same SQL
-//! against the engine, which serialises on DuckDB's internal locks; many tabs
-//! / clients open at once peg the read API behind that lock even though the
-//! underlying answer hasn't changed in hours.
-//!
-//! The cache is a generation-keyed, single-flight store of [`Arc`]-wrapped
-//! payloads, one [`DashMap`] per result type:
-//! - reads check the slot, clone the [`Arc`] out, and return — no DuckDB
-//!   round-trip on the hot path;
-//! - the first miss for a key runs `compute` while concurrent waiters share the
-//!   same async slot;
-//! - [`QueryCache::invalidate`] is called from [`crate::ingest`] after a
-//!   successful commit; it advances the generation and clears the visible
-//!   maps so old in-flight computes cannot repopulate the current snapshot.
-//!
-//! The two unkeyed slots — `/api/groups` and the filter universe — use a
-//! [`DashMap`] with `()` as the logical key, so every slot in the cache is the
-//! same primitive.
-//!
-//! Cached values are wrapped in [`std::sync::Arc`] and never deep-cloned on
-//! the cache-hit path. The JSON bytes are still serialized per fallback
-//! response; the materialized latest-100 hot path lives in
-//! [`crate::read_model`].
-
-use std::future::Future;
-use std::hash::Hash;
-use std::sync::Arc;
-use std::sync::atomic::AtomicU64;
-use std::sync::atomic::Ordering;
-
-use anyhow::Result;
-use dashmap::DashMap;
-use tokio::sync::Mutex as AsyncMutex;
-
-use crate::api::ChartResponse;
-use crate::api::CommitWindow;
-use crate::api::FilterUniverse;
-use crate::api::Group;
-use crate::api::GroupChartsResponse;
-
-/// Composite cache for every read-side DuckDB query.
-///
-/// Cheap to clone via [`Arc`]; one instance is owned by [`crate::app::AppState`]
-/// for the lifetime of the server. All entries are cleared by
-/// [`Self::invalidate`] when ingest changes the underlying snapshot.
-#[derive(Default)]
-pub struct QueryCache {
-    /// Monotonically advances whenever ingest invalidates the read snapshot.
-    generation: AtomicU64,
-    /// `/api/groups` discovery result. Keyed by `()` because there is only
-    /// ever one group list per snapshot.
-    groups: DashMap<VersionedKey<()>, CacheSlot<Arc<Vec<Group>>>>,
-    /// Global filter universe (engines + formats). Also unkeyed.
-    filter_universe: DashMap<VersionedKey<()>, CacheSlot<Arc<FilterUniverse>>>,
-    /// Per-chart payloads, keyed by `(slug, window)`.
-    chart_payloads: DashMap<VersionedKey<ChartCacheKey>, CacheSlot<Option<Arc<ChartResponse>>>>,
-    /// Per-group payloads, keyed by `(slug, window)`.
-    group_charts: DashMap<VersionedKey<GroupCacheKey>, CacheSlot<Option<Arc<GroupChartsResponse>>>>,
-}
-
-type CacheSlot<T> = Arc<AsyncMutex<Option<T>>>;
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-struct VersionedKey<K> {
-    generation: u64,
-    key: K,
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-struct ChartCacheKey {
-    slug: String,
-    window: CommitWindow,
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-struct GroupCacheKey {
-    slug: String,
-    window: CommitWindow,
-}
-
-impl QueryCache {
-    /// Build an empty cache. Equivalent to [`Self::default`].
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    async fn get_or_compute<K, V, Raw, F, Fut, Wrap>(
-        &self,
-        map: &DashMap<VersionedKey<K>, CacheSlot<V>>,
-        key: K,
-        compute: F,
-        wrap: Wrap,
-    ) -> Result<V>
-    where
-        K: Clone + Eq + Hash,
-        V: Clone,
-        F: FnOnce() -> Fut,
-        Fut: Future<Output = Result<Raw>>,
-        Wrap: FnOnce(Raw) -> V,
-    {
-        let generation = self.generation.load(Ordering::Acquire);
-        let cache_key = VersionedKey { generation, key };
-        let slot = map
-            .entry(cache_key.clone())
-            .or_insert_with(|| Arc::new(AsyncMutex::new(None)))
-            .clone();
-
-        let mut guard = slot.lock().await;
-        if let Some(value) = guard.as_ref() {
-            return Ok(value.clone());
-        }
-
-        let fresh = wrap(compute().await?);
-        if self.generation.load(Ordering::Acquire) == generation {
-            *guard = Some(fresh.clone());
-        } else {
-            map.remove(&cache_key);
-        }
-        Ok(fresh)
-    }
-
-    /// Get the cached `Arc<Vec<Group>>` from `/api/groups`, or run `compute`
-    /// if the slot is empty and store the result.
-    pub async fn groups<F, Fut>(&self, compute: F) -> Result<Arc<Vec<Group>>>
-    where
-        F: FnOnce() -> Fut,
-        Fut: Future<Output = Result<Vec<Group>>>,
-    {
-        self.get_or_compute(&self.groups, (), compute, Arc::new)
-            .await
-    }
-
-    /// Get the cached `Arc<FilterUniverse>` for the global filter bar, or
-    /// run `compute` if the slot is empty and store the result.
-    pub async fn filter_universe<F, Fut>(&self, compute: F) -> Result<Arc<FilterUniverse>>
-    where
-        F: FnOnce() -> Fut,
-        Fut: Future<Output = Result<FilterUniverse>>,
-    {
-        self.get_or_compute(&self.filter_universe, (), compute, Arc::new)
-            .await
-    }
-
-    /// Get the cached chart payload for `(slug, window)`, or run `compute`
-    /// if the entry is absent and store the result. The cached value is
-    /// `Option<Arc<ChartResponse>>` so a confirmed "no data for this slug"
-    /// answer is cached too — repeated 404s do not re-hit DuckDB.
-    pub async fn chart_payload<F, Fut>(
-        &self,
-        slug: &str,
-        window: &CommitWindow,
-        compute: F,
-    ) -> Result<Option<Arc<ChartResponse>>>
-    where
-        F: FnOnce() -> Fut,
-        Fut: Future<Output = Result<Option<ChartResponse>>>,
-    {
-        let key = ChartCacheKey {
-            slug: slug.to_string(),
-            window: *window,
-        };
-        self.get_or_compute(&self.chart_payloads, key, compute, |value| {
-            value.map(Arc::new)
-        })
-        .await
-    }
-
-    /// Get the cached per-group payload for `(slug, window)`, or run
-    /// `compute` if the entry is absent and store the result.
-    pub async fn group_charts<F, Fut>(
-        &self,
-        slug: &str,
-        window: &CommitWindow,
-        compute: F,
-    ) -> Result<Option<Arc<GroupChartsResponse>>>
-    where
-        F: FnOnce() -> Fut,
-        Fut: Future<Output = Result<Option<GroupChartsResponse>>>,
-    {
-        let key = GroupCacheKey {
-            slug: slug.to_string(),
-            window: *window,
-        };
-        self.get_or_compute(&self.group_charts, key, compute, |value| {
-            value.map(Arc::new)
-        })
-        .await
-    }
-
-    /// Drop every cached value. Called from the ingest handler after a
-    /// successful commit so the next read sees the fresh snapshot.
-    pub fn invalidate(&self) {
-        self.generation.fetch_add(1, Ordering::AcqRel);
-        self.groups.clear();
-        self.filter_universe.clear();
-        self.chart_payloads.clear();
-        self.group_charts.clear();
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::atomic::AtomicUsize;
-    use std::sync::atomic::Ordering;
-    use std::time::Duration;
-
-    use anyhow::anyhow;
-    use tokio::sync::oneshot;
-
-    use super::*;
-    use crate::api::FilterUniverse;
-
-    fn empty_universe() -> FilterUniverse {
-        FilterUniverse::default()
-    }
-
-    fn universe_with_engine(engine: &str) -> FilterUniverse {
-        FilterUniverse {
-            engines: vec![engine.to_string()],
-            formats: Vec::new(),
-        }
-    }
-
-    #[tokio::test]
-    async fn singleton_caches_and_returns_same_arc() -> Result<()> {
-        let cache = QueryCache::new();
-        let calls = AtomicUsize::new(0);
-
-        let a = cache
-            .filter_universe(|| {
-                calls.fetch_add(1, Ordering::SeqCst);
-                async { Ok(empty_universe()) }
-            })
-            .await?;
-        let b = cache
-            .filter_universe(|| {
-                calls.fetch_add(1, Ordering::SeqCst);
-                async { Ok(empty_universe()) }
-            })
-            .await?;
-
-        assert_eq!(calls.load(Ordering::SeqCst), 1, "compute should run once");
-        assert!(Arc::ptr_eq(&a, &b), "cache returns the same Arc");
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn invalidate_clears_singleton() -> Result<()> {
-        let cache = QueryCache::new();
-        let calls = AtomicUsize::new(0);
-
-        let a = cache
-            .filter_universe(|| {
-                calls.fetch_add(1, Ordering::SeqCst);
-                async { Ok(empty_universe()) }
-            })
-            .await?;
-        cache.invalidate();
-        let b = cache
-            .filter_universe(|| {
-                calls.fetch_add(1, Ordering::SeqCst);
-                async { Ok(empty_universe()) }
-            })
-            .await?;
-
-        assert_eq!(
-            calls.load(Ordering::SeqCst),
-            2,
-            "invalidate should force a recompute"
-        );
-        assert!(
-            !Arc::ptr_eq(&a, &b),
-            "post-invalidate read should produce a fresh Arc"
-        );
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn concurrent_singleton_misses_share_one_compute() -> Result<()> {
-        let cache = Arc::new(QueryCache::new());
-        let calls = Arc::new(AtomicUsize::new(0));
-        let mut tasks = Vec::new();
-
-        for _ in 0..16 {
-            let cache = Arc::clone(&cache);
-            let calls = Arc::clone(&calls);
-            tasks.push(tokio::spawn(async move {
-                cache
-                    .filter_universe(|| {
-                        calls.fetch_add(1, Ordering::SeqCst);
-                        async {
-                            tokio::time::sleep(Duration::from_millis(50)).await;
-                            Ok(empty_universe())
-                        }
-                    })
-                    .await
-            }));
-        }
-
-        for task in tasks {
-            task.await??;
-        }
-
-        assert_eq!(
-            calls.load(Ordering::SeqCst),
-            1,
-            "concurrent misses for one key should collapse to one compute"
-        );
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn stale_in_flight_compute_does_not_repopulate_after_invalidate() -> Result<()> {
-        let cache = Arc::new(QueryCache::new());
-        let (started_tx, started_rx) = oneshot::channel();
-        let (release_tx, release_rx) = oneshot::channel();
-
-        let stale_cache = Arc::clone(&cache);
-        let stale_task = tokio::spawn(async move {
-            stale_cache
-                .filter_universe(|| {
-                    started_tx.send(()).expect("test receiver is alive");
-                    async {
-                        release_rx
-                            .await
-                            .expect("test sender releases stale compute");
-                        Ok(universe_with_engine("stale"))
-                    }
-                })
-                .await
-        });
-
-        started_rx.await?;
-        cache.invalidate();
-
-        let fresh = cache
-            .filter_universe(|| async { Ok(universe_with_engine("fresh")) })
-            .await?;
-        assert_eq!(fresh.engines, ["fresh"]);
-
-        release_tx.send(()).expect("stale compute is waiting");
-        let stale = stale_task.await??;
-        assert_eq!(stale.engines, ["stale"]);
-
-        let cached = cache
-            .filter_universe(|| async { Ok(universe_with_engine("unexpected")) })
-            .await?;
-        assert_eq!(
-            cached.engines,
-            ["fresh"],
-            "old in-flight computations must not populate the new generation"
-        );
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn chart_payload_keyed_by_slug_and_window() -> Result<()> {
-        let cache = QueryCache::new();
-        let calls = AtomicUsize::new(0);
-
-        let make = |display_name: &str| {
-            let display_name = display_name.to_string();
-            ChartResponse {
-                display_name,
-                unit_kind: crate::api::UnitKind::TimeNs,
-                history: crate::api::ChartHistory {
-                    total_commits: 0,
-                    start_index: 0,
-                    loaded_commits: 0,
-                    complete: true,
-                },
-                commits: Vec::new(),
-                series: serde_json::Map::new(),
-                series_meta: std::collections::BTreeMap::new(),
-            }
-        };
-
-        let one = cache
-            .chart_payload("a", &CommitWindow::All, || {
-                calls.fetch_add(1, Ordering::SeqCst);
-                async { Ok(Some(make("first"))) }
-            })
-            .await?
-            .expect("Some");
-        let _two = cache
-            .chart_payload("a", &CommitWindow::All, || {
-                calls.fetch_add(1, Ordering::SeqCst);
-                async { Ok(Some(make("second"))) }
-            })
-            .await?
-            .expect("Some");
-        // Different window — should be a separate cache slot.
-        let three = cache
-            .chart_payload(
-                "a",
-                &CommitWindow::Last(std::num::NonZeroU32::new(10).unwrap()),
-                || {
-                    calls.fetch_add(1, Ordering::SeqCst);
-                    async { Ok(Some(make("third"))) }
-                },
-            )
-            .await?
-            .expect("Some");
-
-        assert_eq!(calls.load(Ordering::SeqCst), 2);
-        assert_eq!(one.display_name, "first");
-        assert_eq!(three.display_name, "third");
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn chart_payload_caches_negative_result() -> Result<()> {
-        let cache = QueryCache::new();
-        let calls = AtomicUsize::new(0);
-
-        let none1 = cache
-            .chart_payload("missing", &CommitWindow::All, || {
-                calls.fetch_add(1, Ordering::SeqCst);
-                async { Ok(None) }
-            })
-            .await?;
-        let none2 = cache
-            .chart_payload("missing", &CommitWindow::All, || {
-                calls.fetch_add(1, Ordering::SeqCst);
-                async { Ok(None) }
-            })
-            .await?;
-
-        assert!(none1.is_none() && none2.is_none());
-        assert_eq!(
-            calls.load(Ordering::SeqCst),
-            1,
-            "the second read for a missing slug should hit the cache, not re-query"
-        );
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn errors_do_not_populate_cache() -> Result<()> {
-        let cache = QueryCache::new();
-        let calls = AtomicUsize::new(0);
-
-        let res = cache
-            .filter_universe(|| {
-                calls.fetch_add(1, Ordering::SeqCst);
-                async { Err::<FilterUniverse, _>(anyhow!("boom")) }
-            })
-            .await;
-        assert!(res.is_err(), "error path bubbles up");
-
-        cache
-            .filter_universe(|| {
-                calls.fetch_add(1, Ordering::SeqCst);
-                async { Ok(empty_universe()) }
-            })
-            .await?;
-        assert_eq!(
-            calls.load(Ordering::SeqCst),
-            2,
-            "second call must rerun after an errored first call",
-        );
-        Ok(())
-    }
-}
diff --git a/benchmarks-website/server/src/read_model.rs b/benchmarks-website/server/src/read_model.rs
deleted file mode 100644
index b2aa0e21868..00000000000
--- a/benchmarks-website/server/src/read_model.rs
+++ /dev/null
@@ -1,837 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Materialized read model for the hot benchmark website paths.
-//!
-//! DuckDB remains the source of truth, but the normal latest-100 website
-//! payloads are deterministic between ingests. This module builds those
-//! payloads once per database snapshot, stores identity/gzip/brotli bytes in
-//! memory, and lets handlers serve bytes directly on the hot path.
-
-use std::collections::VecDeque;
-use std::future::Future;
-use std::hash::Hasher as _;
-use std::io::Read as _;
-use std::io::Write as _;
-use std::num::NonZeroU32;
-use std::pin::Pin;
-use std::sync::Arc;
-
-use anyhow::Context as _;
-use anyhow::Result;
-use axum::body::Body;
-use axum::http::HeaderMap;
-use axum::http::HeaderValue;
-use axum::http::StatusCode;
-use axum::http::header;
-use axum::response::Response;
-use bytes::Bytes;
-use duckdb::Connection;
-use flate2::Compression;
-use flate2::write::GzEncoder;
-use parking_lot::RwLock;
-use serde::Serialize;
-use tokio::sync::Mutex as AsyncMutex;
-use twox_hash::XxHash64;
-use vortex_utils::aliases::hash_map::HashMap;
-
-use crate::api;
-use crate::api::ChartResponse;
-use crate::api::CommitWindow;
-use crate::api::FilterUniverse;
-use crate::api::Group;
-use crate::api::GroupChartsResponse;
-use crate::api::GroupsResponse;
-use crate::api::NamedChartResponse;
-use crate::api::Summary;
-use crate::db;
-use crate::db::DbHandle;
-use crate::slug::ChartKey;
-
-/// Number of charts included in one materialized group shard response.
-pub const GROUP_SHARD_CHARTS: usize = 8;
-
-/// Superseded read generations retained for pages opened before newer ingests
-/// completed. Each generation owns precompressed latest-100 artifacts, so keep
-/// this finite while covering ordinary CI bursts.
-const RETAINED_PREVIOUS_GENERATIONS: usize = 8;
-
-/// Cache policy for a materialized artifact route.
-#[derive(Debug, Clone, Copy)]
-pub enum ArtifactCachePolicy {
-    /// Stable URLs such as `/api/groups`; browsers should revalidate.
-    Revalidate,
-    /// Versioned URLs under `/api/artifacts/{generation}/...`.
-    Immutable,
-}
-
-impl ArtifactCachePolicy {
-    fn header_value(self) -> &'static str {
-        match self {
-            Self::Revalidate => "no-cache, max-age=0, must-revalidate",
-            Self::Immutable => "public, max-age=31536000, immutable",
-        }
-    }
-}
-
-/// A JSON artifact encoded in every representation the server wants to serve.
-#[derive(Debug, Clone)]
-pub struct EncodedArtifact {
-    identity: Bytes,
-    gzip: Bytes,
-    br: Bytes,
-    etag: HeaderValue,
-}
-
-impl EncodedArtifact {
-    fn new(generation_id: &str, identity: Vec<u8>) -> Result<Self> {
-        let gzip = gzip_bytes(&identity).context("gzip artifact")?;
-        let br = brotli_bytes(&identity).context("brotli artifact")?;
-        let etag = HeaderValue::from_str(&format!("\"{generation_id}\""))
-            .context("building artifact ETag")?;
-        Ok(Self {
-            identity: Bytes::from(identity),
-            gzip: Bytes::from(gzip),
-            br: Bytes::from(br),
-            etag,
-        })
-    }
-
-    /// Uncompressed bytes, used when an HTML page embeds a single chart.
-    pub fn identity(&self) -> &Bytes {
-        &self.identity
-    }
-
-    /// Build an Axum response using the client's `Accept-Encoding` and
-    /// `If-None-Match` headers.
-    pub fn response(&self, request_headers: &HeaderMap, policy: ArtifactCachePolicy) -> Response {
-        if if_none_match_matches(request_headers, &self.etag) {
-            return artifact_response_builder(StatusCode::NOT_MODIFIED, policy, &self.etag)
-                .body(Body::empty())
-                .expect("artifact 304 response");
-        }
-
-        let (encoding, bytes) = match preferred_encoding(request_headers) {
-            ArtifactEncoding::Brotli => (Some("br"), self.br.clone()),
-            ArtifactEncoding::Gzip => (Some("gzip"), self.gzip.clone()),
-            ArtifactEncoding::Identity => (None, self.identity.clone()),
-        };
-
-        let mut builder = artifact_response_builder(StatusCode::OK, policy, &self.etag)
-            .header(header::CONTENT_TYPE, "application/json")
-            .header(header::CONTENT_LENGTH, bytes.len().to_string());
-        if let Some(encoding) = encoding {
-            builder = builder.header(header::CONTENT_ENCODING, encoding);
-        }
-        builder.body(Body::from(bytes)).expect("artifact response")
-    }
-}
-
-fn artifact_response_builder(
-    status: StatusCode,
-    policy: ArtifactCachePolicy,
-    etag: &HeaderValue,
-) -> axum::http::response::Builder {
-    Response::builder()
-        .status(status)
-        .header(header::CACHE_CONTROL, policy.header_value())
-        .header(header::VARY, "Accept-Encoding")
-        .header(header::ETAG, etag.clone())
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum ArtifactEncoding {
-    Brotli,
-    Gzip,
-    Identity,
-}
-
-fn preferred_encoding(headers: &HeaderMap) -> ArtifactEncoding {
-    let Some(raw) = headers
-        .get(header::ACCEPT_ENCODING)
-        .and_then(|v| v.to_str().ok())
-    else {
-        return ArtifactEncoding::Identity;
-    };
-    if accepts_encoding(raw, "br") {
-        ArtifactEncoding::Brotli
-    } else if accepts_encoding(raw, "gzip") {
-        ArtifactEncoding::Gzip
-    } else {
-        ArtifactEncoding::Identity
-    }
-}
-
-fn accepts_encoding(raw: &str, expected: &str) -> bool {
-    raw.split(',').any(|part| {
-        let mut pieces = part.trim().split(';');
-        let name = pieces.next().unwrap_or_default().trim();
-        if !name.eq_ignore_ascii_case(expected) {
-            return false;
-        }
-        pieces.all(|piece| {
-            let piece = piece.trim();
-            let Some((key, value)) = piece.split_once('=') else {
-                return true;
-            };
-            if !key.trim().eq_ignore_ascii_case("q") {
-                return true;
-            }
-            // Per RFC 9110 the q value is a positive number in [0, 1]; we
-            // reject `q=0` (client refuses the encoding) AND reject
-            // malformed q-values (`q=foo`, `q=`, `q=inf`, `q=NaN`, `q=2`).
-            // The earlier `map_or(true, |q| q > 0.0)` treated every parse
-            // failure as accept, which is non-conformant in the
-            // opposite direction.
-            match value.trim().parse::<f32>() {
-                Ok(q) if q.is_finite() && (0.0..=1.0).contains(&q) => q > 0.0,
-                _ => false,
-            }
-        })
-    })
-}
-
-fn if_none_match_matches(headers: &HeaderMap, etag: &HeaderValue) -> bool {
-    let Some(raw) = headers
-        .get(header::IF_NONE_MATCH)
-        .and_then(|v| v.to_str().ok())
-    else {
-        return false;
-    };
-    let etag = etag.to_str().unwrap_or_default();
-    raw.split(',').any(|candidate| {
-        let candidate = candidate.trim();
-        candidate == "*" || candidate == etag
-    })
-}
-
-fn gzip_bytes(bytes: &[u8]) -> Result<Vec<u8>> {
-    let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
-    encoder.write_all(bytes)?;
-    Ok(encoder.finish()?)
-}
-
-fn brotli_bytes(bytes: &[u8]) -> Result<Vec<u8>> {
-    let mut reader = brotli::CompressorReader::new(bytes, 4096, 5, 22);
-    let mut out = Vec::new();
-    reader.read_to_end(&mut out)?;
-    Ok(out)
-}
-
-type RebuildFuture = Pin<Box<dyn Future<Output = Result<ReadGeneration>> + Send>>;
-type RebuildTask = Arc<dyn Fn() -> RebuildFuture + Send + Sync>;
-
-/// Shared in-memory store for the active and recently superseded read
-/// generations.
-#[derive(Clone)]
-pub struct ReadStore {
-    inner: Arc<RwLock<ReadStoreInner>>,
-    rebuild: Arc<AsyncMutex<RebuildState>>,
-}
-
-struct ReadStoreInner {
-    active: Arc<ReadGeneration>,
-    previous: VecDeque<Arc<ReadGeneration>>,
-}
-
-#[derive(Default)]
-struct RebuildState {
-    running: bool,
-    pending: bool,
-}
-
-impl ReadStore {
-    /// Build the first generation synchronously during startup. Failure here
-    /// fails server startup rather than pushing a cold build onto users.
-    pub fn build_initial(db: &DbHandle) -> Result<Self> {
-        let mut conn = db.connection()?;
-        let generation = Arc::new(build_generation(&mut conn)?);
-        Ok(Self {
-            inner: Arc::new(RwLock::new(ReadStoreInner {
-                active: generation,
-                previous: VecDeque::new(),
-            })),
-            rebuild: Arc::new(AsyncMutex::new(RebuildState::default())),
-        })
-    }
-
-    /// Current generation.
-    pub fn active(&self) -> Arc<ReadGeneration> {
-        Arc::clone(&self.inner.read().active)
-    }
-
-    /// Find the active or retained previous generation by id.
-    pub fn generation(&self, id: &str) -> Option<Arc<ReadGeneration>> {
-        let inner = self.inner.read();
-        if inner.active.id == id {
-            return Some(Arc::clone(&inner.active));
-        }
-        inner
-            .previous
-            .iter()
-            .find(|generation| generation.id == id)
-            .map(Arc::clone)
-    }
-
-    /// Schedule a background rebuild after ingest. The active generation is
-    /// retained until the rebuild succeeds, and repeated ingests coalesce into
-    /// at most one follow-up rebuild.
-    pub async fn schedule_rebuild(&self, db: DbHandle) {
-        let build: RebuildTask = Arc::new(move || {
-            let db = db.clone();
-            Box::pin(async move { db::run_read_blocking(&db, build_generation).await })
-        });
-        self.schedule_rebuild_with(build).await;
-    }
-
-    async fn schedule_rebuild_with(&self, build: RebuildTask) {
-        let mut state = self.rebuild.lock().await;
-        if state.running {
-            state.pending = true;
-            return;
-        }
-        state.running = true;
-        let store = self.clone();
-        tokio::spawn(async move {
-            store.rebuild_loop(build).await;
-        });
-    }
-
-    async fn rebuild_loop(self, build: RebuildTask) {
-        loop {
-            match build().await {
-                Ok(generation) => self.install(generation),
-                Err(err) => {
-                    tracing::error!(error = ?err, "read model rebuild failed");
-                }
-            }
-
-            let mut state = self.rebuild.lock().await;
-            if state.pending {
-                state.pending = false;
-                continue;
-            }
-            state.running = false;
-            break;
-        }
-    }
-
-    fn install(&self, generation: ReadGeneration) {
-        let mut inner = self.inner.write();
-        let previous = Arc::clone(&inner.active);
-        inner.active = Arc::new(generation);
-        inner.previous.push_front(previous);
-        while inner.previous.len() > RETAINED_PREVIOUS_GENERATIONS {
-            inner.previous.pop_back();
-        }
-    }
-}
-
-/// One immutable read snapshot.
-pub struct ReadGeneration {
-    id: String,
-    groups: Arc<Vec<Group>>,
-    filter_universe: Arc<FilterUniverse>,
-    groups_artifact: EncodedArtifact,
-    chart_artifacts: HashMap<String, EncodedArtifact>,
-    group_artifacts: HashMap<String, EncodedArtifact>,
-    group_shards: HashMap<GroupShardKey, EncodedArtifact>,
-    group_shard_counts: HashMap<String, usize>,
-    chart_payloads: HashMap<String, Arc<ChartResponse>>,
-}
-
-impl ReadGeneration {
-    /// Content-derived generation id.
-    pub fn id(&self) -> &str {
-        &self.id
-    }
-
-    /// Structured groups for HTML rendering.
-    pub fn groups(&self) -> Arc<Vec<Group>> {
-        Arc::clone(&self.groups)
-    }
-
-    /// Structured filter universe for HTML rendering.
-    pub fn filter_universe(&self) -> Arc<FilterUniverse> {
-        Arc::clone(&self.filter_universe)
-    }
-
-    /// Materialized `/api/groups` body.
-    pub fn groups_artifact(&self) -> &EncodedArtifact {
-        &self.groups_artifact
-    }
-
-    /// Materialized latest-100 `/api/chart/{slug}` body.
-    pub fn chart_artifact(&self, slug: &str) -> Option<&EncodedArtifact> {
-        self.chart_artifacts.get(slug)
-    }
-
-    /// Materialized latest-100 `/api/group/{slug}` compatibility body.
-    pub fn group_artifact(&self, slug: &str) -> Option<&EncodedArtifact> {
-        self.group_artifacts.get(slug)
-    }
-
-    /// Materialized latest-100 shard body for landing/group hydration.
-    pub fn group_shard_artifact(&self, slug: &str, index: usize) -> Option<&EncodedArtifact> {
-        self.group_shards.get(&GroupShardKey {
-            slug: slug.to_string(),
-            index,
-        })
-    }
-
-    /// Number of materialized shards for a group.
-    pub fn group_shard_count(&self, slug: &str) -> usize {
-        self.group_shard_counts.get(slug).copied().unwrap_or(0)
-    }
-
-    /// Structured latest-100 chart payload for single-chart HTML rendering.
-    pub fn chart_payload(&self, slug: &str) -> Option<Arc<ChartResponse>> {
-        self.chart_payloads.get(slug).map(Arc::clone)
-    }
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-struct GroupShardKey {
-    slug: String,
-    index: usize,
-}
-
-#[derive(Serialize)]
-struct GroupShardResponse {
-    name: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    summary: Option<Summary>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    description: Option<String>,
-    window: u32,
-    shard_index: usize,
-    shard_count: usize,
-    charts: Vec<NamedChartResponse>,
-}
-
-struct RawArtifact {
-    key: String,
-    kind: RawArtifactKind,
-    bytes: Vec<u8>,
-}
-
-enum RawArtifactKind {
-    Groups,
-    Chart { slug: String },
-    Group { slug: String },
-    GroupShard { slug: String, index: usize },
-}
-
-fn build_generation(conn: &mut Connection) -> Result<ReadGeneration> {
-    api::read_transaction(conn, build_generation_from_snapshot)
-}
-
-fn build_generation_from_snapshot(conn: &Connection) -> Result<ReadGeneration> {
-    let groups = Arc::new(api::collect_groups(conn)?);
-    let filter_universe = Arc::new(api::collect_filter_universe(conn)?);
-    let window = CommitWindow::Last(
-        NonZeroU32::new(api::DEFAULT_COMMIT_WINDOW).expect("default window is non-zero"),
-    );
-
-    let mut raw = Vec::new();
-    raw.push(RawArtifact {
-        key: "api:groups".to_string(),
-        kind: RawArtifactKind::Groups,
-        bytes: serde_json::to_vec(&GroupsResponse {
-            groups: Arc::clone(&groups),
-        })
-        .context("serialize groups artifact")?,
-    });
-
-    let mut chart_payloads = HashMap::new();
-    let mut group_shard_counts = HashMap::new();
-
-    for group in groups.iter() {
-        let mut charts = Vec::with_capacity(group.charts.len());
-        for link in &group.charts {
-            let chart = if let Some(chart) = chart_payloads.get(&link.slug) {
-                Arc::clone(chart)
-            } else {
-                let key = ChartKey::from_slug(&link.slug)
-                    .with_context(|| format!("invalid chart slug in group: {}", link.slug))?;
-                let Some(chart) = api::chart_payload(conn, &key, &window)? else {
-                    continue;
-                };
-                let chart = Arc::new(chart);
-                raw.push(RawArtifact {
-                    key: format!("api:chart:{}:100", link.slug),
-                    kind: RawArtifactKind::Chart {
-                        slug: link.slug.clone(),
-                    },
-                    bytes: serde_json::to_vec(chart.as_ref())
-                        .with_context(|| format!("serialize chart artifact {}", link.slug))?,
-                });
-                chart_payloads.insert(link.slug.clone(), Arc::clone(&chart));
-                chart
-            };
-            charts.push(NamedChartResponse {
-                name: link.name.clone(),
-                slug: link.slug.clone(),
-                chart,
-            });
-        }
-
-        if charts.is_empty() {
-            group_shard_counts.insert(group.slug.clone(), 0);
-            continue;
-        }
-
-        let group_response = GroupChartsResponse {
-            name: group.name.clone(),
-            summary: group.summary.clone(),
-            description: group.description.clone(),
-            charts: charts.clone(),
-        };
-        raw.push(RawArtifact {
-            key: format!("api:group:{}:100", group.slug),
-            kind: RawArtifactKind::Group {
-                slug: group.slug.clone(),
-            },
-            bytes: serde_json::to_vec(&group_response)
-                .with_context(|| format!("serialize group artifact {}", group.slug))?,
-        });
-
-        let shard_count = charts.len().div_ceil(GROUP_SHARD_CHARTS);
-        group_shard_counts.insert(group.slug.clone(), shard_count);
-        for (shard_index, chunk) in charts.chunks(GROUP_SHARD_CHARTS).enumerate() {
-            let shard = GroupShardResponse {
-                name: group.name.clone(),
-                summary: group.summary.clone(),
-                description: group.description.clone(),
-                window: api::DEFAULT_COMMIT_WINDOW,
-                shard_index,
-                shard_count,
-                charts: chunk.to_vec(),
-            };
-            raw.push(RawArtifact {
-                key: format!("api:group-shard:{}:{shard_index}:100", group.slug),
-                kind: RawArtifactKind::GroupShard {
-                    slug: group.slug.clone(),
-                    index: shard_index,
-                },
-                bytes: serde_json::to_vec(&shard).with_context(|| {
-                    format!(
-                        "serialize group shard artifact {}#{shard_index}",
-                        group.slug
-                    )
-                })?,
-            });
-        }
-    }
-
-    let id = generation_id(&raw);
-    let mut groups_artifact = None;
-    let mut chart_artifacts = HashMap::new();
-    let mut group_artifacts = HashMap::new();
-    let mut group_shards = HashMap::new();
-
-    for artifact in raw {
-        let encoded = EncodedArtifact::new(&id, artifact.bytes)
-            .with_context(|| format!("encode artifact {}", artifact.key))?;
-        match artifact.kind {
-            RawArtifactKind::Groups => groups_artifact = Some(encoded),
-            RawArtifactKind::Chart { slug } => {
-                chart_artifacts.insert(slug, encoded);
-            }
-            RawArtifactKind::Group { slug } => {
-                group_artifacts.insert(slug, encoded);
-            }
-            RawArtifactKind::GroupShard { slug, index } => {
-                group_shards.insert(GroupShardKey { slug, index }, encoded);
-            }
-        }
-    }
-
-    Ok(ReadGeneration {
-        id,
-        groups,
-        filter_universe,
-        groups_artifact: groups_artifact.context("groups artifact missing")?,
-        chart_artifacts,
-        group_artifacts,
-        group_shards,
-        group_shard_counts,
-        chart_payloads,
-    })
-}
-
-fn generation_id(raw: &[RawArtifact]) -> String {
-    let mut sorted: Vec<_> = raw.iter().collect();
-    sorted.sort_by(|a, b| a.key.cmp(&b.key));
-    let mut hash = XxHash64::with_seed(0);
-    for artifact in sorted {
-        hash.write_u64(artifact.key.len() as u64);
-        hash.write(artifact.key.as_bytes());
-        hash.write_u64(artifact.bytes.len() as u64);
-        hash.write(&artifact.bytes);
-    }
-    format!("{:016x}", hash.finish())
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::atomic::AtomicUsize;
-    use std::sync::atomic::Ordering;
-    use std::time::Duration;
-
-    use axum::http::header;
-    use tokio::sync::Notify;
-    use tokio::time::sleep;
-
-    use super::*;
-
-    fn raw_artifact(key: &str, bytes: &[u8]) -> RawArtifact {
-        RawArtifact {
-            key: key.to_string(),
-            kind: RawArtifactKind::Groups,
-            bytes: bytes.to_vec(),
-        }
-    }
-
-    fn empty_generation(id: &str) -> Result<ReadGeneration> {
-        Ok(ReadGeneration {
-            id: id.to_string(),
-            groups: Arc::new(Vec::new()),
-            filter_universe: Arc::new(FilterUniverse::default()),
-            groups_artifact: EncodedArtifact::new(id, br#"{"groups":[]}"#.to_vec())?,
-            chart_artifacts: HashMap::new(),
-            group_artifacts: HashMap::new(),
-            group_shards: HashMap::new(),
-            group_shard_counts: HashMap::new(),
-            chart_payloads: HashMap::new(),
-        })
-    }
-
-    fn test_store(id: &str) -> Result<ReadStore> {
-        Ok(ReadStore {
-            inner: Arc::new(RwLock::new(ReadStoreInner {
-                active: Arc::new(empty_generation(id)?),
-                previous: VecDeque::new(),
-            })),
-            rebuild: Arc::new(AsyncMutex::new(RebuildState::default())),
-        })
-    }
-
-    async fn wait_for_rebuild_idle(store: &ReadStore) {
-        for _ in 0..100 {
-            if !store.rebuild.lock().await.running {
-                return;
-            }
-            sleep(Duration::from_millis(10)).await;
-        }
-        panic!("read model rebuild did not become idle");
-    }
-
-    async fn wait_for_calls(calls: &AtomicUsize, expected: usize) {
-        for _ in 0..100 {
-            if calls.load(Ordering::SeqCst) >= expected {
-                return;
-            }
-            sleep(Duration::from_millis(10)).await;
-        }
-        panic!("read model rebuild did not start");
-    }
-
-    #[test]
-    fn generation_ids_are_content_derived_and_order_stable() {
-        let a = vec![raw_artifact("b", b"two"), raw_artifact("a", b"one")];
-        let b = vec![raw_artifact("a", b"one"), raw_artifact("b", b"two")];
-        let c = vec![raw_artifact("a", b"one"), raw_artifact("b", b"changed")];
-
-        assert_eq!(generation_id(&a), generation_id(&b));
-        assert_ne!(generation_id(&a), generation_id(&c));
-    }
-
-    #[test]
-    fn encoded_artifact_negotiates_precompressed_variants() -> Result<()> {
-        let artifact = EncodedArtifact::new("abc123", br#"{"ok":true}"#.to_vec())?;
-        let mut headers = HeaderMap::new();
-        headers.insert(header::ACCEPT_ENCODING, HeaderValue::from_static("gzip"));
-
-        let resp = artifact.response(&headers, ArtifactCachePolicy::Immutable);
-        assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(
-            resp.headers()
-                .get(header::CONTENT_ENCODING)
-                .and_then(|v| v.to_str().ok()),
-            Some("gzip")
-        );
-        assert_eq!(
-            resp.headers()
-                .get(header::VARY)
-                .and_then(|v| v.to_str().ok()),
-            Some("Accept-Encoding")
-        );
-        assert!(
-            resp.headers()
-                .get(header::CACHE_CONTROL)
-                .and_then(|v| v.to_str().ok())
-                .is_some_and(|v| v.contains("immutable"))
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn encoded_artifact_honors_nonzero_q_values() -> Result<()> {
-        let artifact = EncodedArtifact::new("abc123", br#"{"ok":true}"#.to_vec())?;
-        let mut headers = HeaderMap::new();
-        headers.insert(
-            header::ACCEPT_ENCODING,
-            HeaderValue::from_static("br;q=0.8, gzip;q=0.5"),
-        );
-
-        let resp = artifact.response(&headers, ArtifactCachePolicy::Immutable);
-        assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(
-            resp.headers()
-                .get(header::CONTENT_ENCODING)
-                .and_then(|v| v.to_str().ok()),
-            Some("br")
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn encoded_artifact_rejects_zero_q_values() -> Result<()> {
-        let artifact = EncodedArtifact::new("abc123", br#"{"ok":true}"#.to_vec())?;
-        let mut headers = HeaderMap::new();
-        headers.insert(
-            header::ACCEPT_ENCODING,
-            HeaderValue::from_static("br;q=0, gzip;q=0"),
-        );
-
-        let resp = artifact.response(&headers, ArtifactCachePolicy::Immutable);
-        assert_eq!(resp.status(), StatusCode::OK);
-        assert!(
-            resp.headers().get(header::CONTENT_ENCODING).is_none(),
-            "q=0 encodings should fall back to identity"
-        );
-        Ok(())
-    }
-
-    /// `accepts_encoding` rejects malformed q-values (parse failure, out
-    /// of range, non-finite). Previously the parser treated every
-    /// non-numeric q-value as `true` (accept), which was non-conformant
-    /// in the opposite direction from the original q=0 bug.
-    #[test]
-    fn accepts_encoding_rejects_malformed_q_values() {
-        // Malformed numeric inputs: not a number, empty, out of range,
-        // non-finite. Each should reject the encoding.
-        for raw in [
-            "gzip;q=foo",
-            "gzip;q=",
-            "gzip;q=2",
-            "gzip;q=1.5",
-            "gzip;q=-0.1",
-            "gzip;q=NaN",
-            "gzip;q=inf",
-        ] {
-            assert!(
-                !accepts_encoding(raw, "gzip"),
-                "should reject malformed q-value: {raw:?}"
-            );
-        }
-        // Valid edge q-values still accepted.
-        for raw in ["gzip", "gzip;q=1", "gzip;q=1.0", "gzip;q=0.001"] {
-            assert!(
-                accepts_encoding(raw, "gzip"),
-                "should accept valid q-value: {raw:?}"
-            );
-        }
-    }
-
-    #[test]
-    fn encoded_artifact_returns_304_for_matching_etag() -> Result<()> {
-        let artifact = EncodedArtifact::new("abc123", br#"{"ok":true}"#.to_vec())?;
-        let mut headers = HeaderMap::new();
-        headers.insert(
-            header::IF_NONE_MATCH,
-            HeaderValue::from_static("\"abc123\""),
-        );
-
-        let resp = artifact.response(&headers, ArtifactCachePolicy::Revalidate);
-        assert_eq!(resp.status(), StatusCode::NOT_MODIFIED);
-        assert_eq!(
-            resp.headers()
-                .get(header::ETAG)
-                .and_then(|v| v.to_str().ok()),
-            Some("\"abc123\"")
-        );
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn failed_rebuild_keeps_old_generation_active() -> Result<()> {
-        let store = test_store("old")?;
-        let build: RebuildTask = Arc::new(|| Box::pin(async { anyhow::bail!("boom") }));
-
-        store.schedule_rebuild_with(build).await;
-        wait_for_rebuild_idle(&store).await;
-
-        assert_eq!(store.active().id(), "old");
-        assert!(store.generation("old").is_some());
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn install_evicts_only_beyond_retained_generation_limit() -> Result<()> {
-        let store = test_store("gen0")?;
-        for idx in 1..=(RETAINED_PREVIOUS_GENERATIONS + 2) {
-            store.install(empty_generation(&format!("gen{idx}"))?);
-        }
-
-        assert_eq!(
-            store.active().id(),
-            &format!("gen{}", RETAINED_PREVIOUS_GENERATIONS + 2)
-        );
-        assert!(
-            store.generation("gen2").is_some(),
-            "oldest retained generation should stay addressable"
-        );
-        assert!(
-            store.generation("gen1").is_none(),
-            "generations beyond the retention window should be evicted"
-        );
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn concurrent_rebuild_requests_coalesce() -> Result<()> {
-        let store = test_store("old")?;
-        let calls = Arc::new(AtomicUsize::new(0));
-        let release_first = Arc::new(Notify::new());
-        let build: RebuildTask = Arc::new({
-            let calls = Arc::clone(&calls);
-            let release_first = Arc::clone(&release_first);
-            move || {
-                let calls = Arc::clone(&calls);
-                let release_first = Arc::clone(&release_first);
-                Box::pin(async move {
-                    let call = calls.fetch_add(1, Ordering::SeqCst) + 1;
-                    if call == 1 {
-                        release_first.notified().await;
-                    }
-                    empty_generation(&format!("gen{call}"))
-                })
-            }
-        });
-
-        store.schedule_rebuild_with(Arc::clone(&build)).await;
-        wait_for_calls(&calls, 1).await;
-        store.schedule_rebuild_with(Arc::clone(&build)).await;
-        store.schedule_rebuild_with(build).await;
-        release_first.notify_one();
-        wait_for_rebuild_idle(&store).await;
-
-        assert_eq!(calls.load(Ordering::SeqCst), 2);
-        assert_eq!(store.active().id(), "gen2");
-        assert!(store.generation("gen1").is_some());
-        assert!(store.generation("old").is_some());
-        Ok(())
-    }
-}
diff --git a/benchmarks-website/server/src/records.rs b/benchmarks-website/server/src/records.rs
deleted file mode 100644
index 446b701e296..00000000000
--- a/benchmarks-website/server/src/records.rs
+++ /dev/null
@@ -1,291 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Wire shapes for `POST /api/ingest`.
-//!
-//! Each [`Record`] variant deserializes one row destined for one of the five
-//! fact tables in [`crate::schema`]. The producer side of the contract lives
-//! in `vortex-bench/src/v3.rs` (the `--gh-json-v3` emitter); when changing a
-//! shape here, change both sides in the same commit.
-//!
-//! ## Records are discriminated by `kind`
-//!
-//! Every record carries a `kind` field that picks one of the five fact
-//! tables; serde drives this with `#[serde(tag = "kind", rename_all =
-//! "snake_case")]`.
-//!
-//! | `kind`               | Destination table       |
-//! |----------------------|-------------------------|
-//! | `query_measurement`  | `query_measurements`    |
-//! | `compression_time`   | `compression_times`     |
-//! | `compression_size`   | `compression_sizes`     |
-//! | `random_access_time` | `random_access_times`   |
-//! | `vector_search_run`  | `vector_search_runs`    |
-//!
-//! Every record struct carries `#[serde(deny_unknown_fields)]`, so unknown
-//! fields surface as a `400` with the offending record's index — version
-//! skew is supposed to fail loudly. Unknown `kind` values produce the same
-//! `400` from the outer enum's tag check.
-//!
-//! ## Ingest envelope
-//!
-//! `POST /api/ingest` accepts one [`Envelope`] per request. The envelope
-//! wraps a heterogeneous batch of records (any mix of `kind`s):
-//!
-//! - `run_meta` — [`RunMeta`] with `benchmark_id`, `schema_version`
-//!   (must equal [`crate::schema::SCHEMA_VERSION`]), and `started_at`.
-//! - `commit` — [`CommitInfo`] with the columns of the `commits` dim table,
-//!   keyed by their column names with `commit_sha` renamed to `sha`. The
-//!   server upserts this row before applying any record.
-//! - `records` — array of per-`kind` records.
-//!
-//! `vortex-bench --gh-json-v3 <path>` writes JSONL of bare records only —
-//! the envelope (`run_meta` + `commit`) is added by the post-ingest script
-//! before POSTing, which keeps the Rust emitter dependency-light and lets
-//! CI fill the commit fields from `${{ github.sha }}` plus `git show`.
-
-use serde::Deserialize;
-
-/// One ingest payload.
-///
-/// `run_meta` and `commit` are added by the post-ingest script around the
-/// JSONL of bare records the Rust emitter writes.
-#[derive(Debug, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct Envelope {
-    /// Per-run metadata, including the wire schema version.
-    pub run_meta: RunMeta,
-    /// Commit context — upserted into `commits` before any record is applied.
-    pub commit: CommitInfo,
-    /// Heterogeneous batch of fact-table records.
-    pub records: Vec<Record>,
-}
-
-/// Run-level metadata. `schema_version` is checked against
-/// [`crate::schema::SCHEMA_VERSION`] before any record is processed.
-#[derive(Debug, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct RunMeta {
-    /// Free-form ID of the producing run (e.g. `bench.yml@<run_id>`).
-    pub benchmark_id: String,
-    /// Wire schema version. Must equal [`crate::schema::SCHEMA_VERSION`].
-    pub schema_version: i32,
-    /// RFC 3339 timestamp at which the run started.
-    pub started_at: String,
-}
-
-/// Columns for the `commits` dim table. The wire field for `commit_sha` is
-/// renamed to `sha` per the contract; every other field name matches the
-/// column name in [`crate::schema`].
-#[derive(Debug, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct CommitInfo {
-    /// 40-hex lowercase commit SHA.
-    pub sha: String,
-    /// RFC 3339 / ISO 8601 timestamp of the commit.
-    pub timestamp: String,
-    /// Full commit message (the server renders only the first line).
-    pub message: String,
-    /// Author's display name.
-    pub author_name: String,
-    /// Author's email.
-    pub author_email: String,
-    /// Committer's display name.
-    pub committer_name: String,
-    /// Committer's email.
-    pub committer_email: String,
-    /// Git tree SHA the commit points at.
-    pub tree_sha: String,
-    /// GitHub URL for the commit (used as the click-through fallback when
-    /// no `(#NNNN)` tag is present in the message).
-    pub url: String,
-}
-
-/// A single ingest record, discriminated by `kind`.
-#[derive(Debug, Deserialize)]
-#[serde(tag = "kind", rename_all = "snake_case")]
-pub enum Record {
-    /// `query_measurement` → `query_measurements` table.
-    QueryMeasurement(QueryMeasurement),
-    /// `compression_time` → `compression_times` table.
-    CompressionTime(CompressionTime),
-    /// `compression_size` → `compression_sizes` table.
-    CompressionSize(CompressionSize),
-    /// `random_access_time` → `random_access_times` table.
-    RandomAccessTime(RandomAccessTime),
-    /// `vector_search_run` → `vector_search_runs` table.
-    VectorSearchRun(VectorSearchRun),
-}
-
-/// SQL query suite measurement (TPC-H, ClickBench, ...). Lands in
-/// `query_measurements`. Field names match the schema columns; per-suite dim
-/// values are documented on
-/// [`vortex_bench::v3::benchmark_dataset_dims`](../../../vortex-bench/src/v3.rs).
-#[derive(Debug, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct QueryMeasurement {
-    /// 40-hex lowercase SHA of the producing commit.
-    pub commit_sha: String,
-    /// Top-level suite (e.g. `tpch`, `clickbench`, `public-bi`).
-    pub dataset: String,
-    /// Categorical sub-name (Public-BI dataset; ClickBench flavor).
-    #[serde(default)]
-    pub dataset_variant: Option<String>,
-    /// TPC SF as a string. Populated for TPC-H/TPC-DS, NULL elsewhere.
-    #[serde(default)]
-    pub scale_factor: Option<String>,
-    /// Query index within the suite. The convention (0-based or 1-based) is
-    /// fixed per suite by the producing bench loop; the migrate classifier
-    /// matches it by parsing literal digits out of `q07`-style v2 chart
-    /// names.
-    pub query_idx: i32,
-    /// Storage backend the run targeted: `nvme` or `s3`. Validated on insert.
-    pub storage: String,
-    /// Engine (`datafusion`, `duckdb`, `vortex`, `arrow`).
-    pub engine: String,
-    /// On-disk format (`parquet`, `vortex-file-compressed`, `lance`, ...).
-    pub format: String,
-    /// Median per-iteration wall time in nanoseconds.
-    pub value_ns: i64,
-    /// Per-iteration wall times in nanoseconds (median of these is `value_ns`).
-    pub all_runtimes_ns: Vec<i64>,
-    /// Peak resident-set bytes during the query, when memory tracking was on.
-    #[serde(default)]
-    pub peak_physical: Option<i64>,
-    /// Peak virtual-memory bytes during the query, when memory tracking was on.
-    #[serde(default)]
-    pub peak_virtual: Option<i64>,
-    /// Resident-set delta across the query, when memory tracking was on.
-    #[serde(default)]
-    pub physical_delta: Option<i64>,
-    /// Virtual-memory delta across the query, when memory tracking was on.
-    #[serde(default)]
-    pub virtual_delta: Option<i64>,
-    /// Host environment triple (e.g. `x86_64-linux-gnu`).
-    #[serde(default)]
-    pub env_triple: Option<String>,
-}
-
-/// Encode-or-decode timing from `compress-bench`. Lands in
-/// `compression_times`.
-#[derive(Debug, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct CompressionTime {
-    /// 40-hex lowercase SHA of the producing commit.
-    pub commit_sha: String,
-    /// Compression dataset name.
-    pub dataset: String,
-    /// Optional dataset variant (reserved; unused at alpha).
-    #[serde(default)]
-    pub dataset_variant: Option<String>,
-    /// On-disk format the timing applies to.
-    pub format: String,
-    /// `encode` or `decode`. The server treats it as opaque on the wire.
-    pub op: String,
-    /// Median per-iteration wall time in nanoseconds.
-    pub value_ns: i64,
-    /// Per-iteration wall times in nanoseconds.
-    pub all_runtimes_ns: Vec<i64>,
-    /// Host environment triple.
-    #[serde(default)]
-    pub env_triple: Option<String>,
-}
-
-/// On-disk size from `compress-bench`. One-shot, no per-iteration data.
-/// Lands in `compression_sizes`. Compression ratios (e.g. `vortex/parquet`)
-/// are NOT a separate record kind — they are computed at read time from
-/// pairs of these rows.
-#[derive(Debug, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct CompressionSize {
-    /// 40-hex lowercase SHA of the producing commit.
-    pub commit_sha: String,
-    /// Compression dataset name.
-    pub dataset: String,
-    /// Optional dataset variant (reserved; unused at alpha).
-    #[serde(default)]
-    pub dataset_variant: Option<String>,
-    /// On-disk format the size applies to.
-    pub format: String,
-    /// Compressed-file size in bytes.
-    pub value_bytes: i64,
-}
-
-/// Take-time timing from `random-access-bench`. Lands in
-/// `random_access_times`. Datasets here (chimp, taxi, ...) are a different
-/// namespace from the SQL query suites' dataset names.
-#[derive(Debug, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct RandomAccessTime {
-    /// 40-hex lowercase SHA of the producing commit.
-    pub commit_sha: String,
-    /// Random-access dataset name.
-    pub dataset: String,
-    /// On-disk format the timing applies to.
-    pub format: String,
-    /// Median per-iteration wall time in nanoseconds.
-    pub value_ns: i64,
-    /// Per-iteration wall times in nanoseconds.
-    pub all_runtimes_ns: Vec<i64>,
-    /// Host environment triple.
-    #[serde(default)]
-    pub env_triple: Option<String>,
-}
-
-/// Cosine-similarity scan from `vector-search-bench`. Lands in
-/// `vector_search_runs`. The only family that emits timing **plus** side
-/// counters in the same row.
-#[derive(Debug, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct VectorSearchRun {
-    /// 40-hex lowercase SHA of the producing commit.
-    pub commit_sha: String,
-    /// Vector dataset name (e.g. `cohere-large-10m`).
-    pub dataset: String,
-    /// Train-split layout label.
-    pub layout: String,
-    /// Compression flavor label.
-    pub flavor: String,
-    /// Cosine threshold passed to the scan filter.
-    pub threshold: f64,
-    /// Median per-scan wall time in nanoseconds.
-    pub value_ns: i64,
-    /// Per-iteration wall times in nanoseconds.
-    pub all_runtimes_ns: Vec<i64>,
-    /// Number of rows that survived the cosine filter.
-    pub matches: i64,
-    /// Total rows scanned.
-    pub rows_scanned: i64,
-    /// Total on-disk bytes scanned.
-    pub bytes_scanned: i64,
-    /// Number of timed iterations. Not part of the dim hash.
-    pub iterations: i32,
-    /// Host environment triple.
-    #[serde(default)]
-    pub env_triple: Option<String>,
-}
-
-impl Record {
-    /// The `commit_sha` referenced by this record. Every record carries one;
-    /// the server checks the envelope's `commit.sha` matches.
-    pub fn commit_sha(&self) -> &str {
-        match self {
-            Self::QueryMeasurement(r) => &r.commit_sha,
-            Self::CompressionTime(r) => &r.commit_sha,
-            Self::CompressionSize(r) => &r.commit_sha,
-            Self::RandomAccessTime(r) => &r.commit_sha,
-            Self::VectorSearchRun(r) => &r.commit_sha,
-        }
-    }
-
-    /// The wire `kind` string. Useful for logging and error messages.
-    pub fn kind(&self) -> &'static str {
-        match self {
-            Self::QueryMeasurement(_) => "query_measurement",
-            Self::CompressionTime(_) => "compression_time",
-            Self::CompressionSize(_) => "compression_size",
-            Self::RandomAccessTime(_) => "random_access_time",
-            Self::VectorSearchRun(_) => "vector_search_run",
-        }
-    }
-}
diff --git a/benchmarks-website/server/src/schema.rs b/benchmarks-website/server/src/schema.rs
deleted file mode 100644
index c181021142d..00000000000
--- a/benchmarks-website/server/src/schema.rs
+++ /dev/null
@@ -1,237 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! DuckDB schema applied on server boot - one `commits` dim plus five fact
-//! tables, one per measurement family.
-//!
-//! ## Design principles
-//!
-//! 1. **One fact table per (dim shape, value shape).** A row in any fact
-//!    table has every value column populated; NULLs only appear in genuinely
-//!    optional dimensions. The five families have different dim shapes, so
-//!    forcing them into one wide table either bloats every row with NULL
-//!    columns or splits a single scan's results across multiple rows that
-//!    have to be re-joined to render one chart.
-//! 2. **No discriminator columns spanning families.** No `metric_kind` enum
-//!    forcing the five shapes into one row.
-//! 3. **No JSON escape hatch.** New benchmark parameters become real columns.
-//!    Adding a nullable column is cheap; the readability win is worth it.
-//! 4. **Hashed primary key per fact table.** Every fact table's
-//!    `measurement_id` is a deterministic 64-bit hash of `commit_sha` plus
-//!    that table's dimensional tuple, computed in
-//!    [`crate::db::measurement_id_query`] et al. Including `commit_sha`
-//!    makes every (commit, dim) pair a distinct row - that is exactly what
-//!    the chart pages render as a time series. Re-emission of the same
-//!    (commit, dim) pair is the upsert case. The hash is **server-internal**
-//!    and never crosses a process boundary; the wire never carries it.
-//! 5. **`commits` is the only dim table.** Engine, format, dataset, etc.
-//!    stay as inline strings; DuckDB's dictionary encoding makes a lookup
-//!    table pointless.
-//! 6. **Ratios are not stored.** Computed at query time from
-//!    `compression_sizes`.
-//!
-//! ## Tables
-//!
-//! - **`commits`** - dim table. `commit_sha` is the PK. `timestamp`,
-//!   `tree_sha`, and `url` are required (the server cannot render a chart
-//!   without them); `message` and the author/committer name + email pair are
-//!   nullable so v2-imported rows that lacked them survive. Populated on
-//!   every `/api/ingest` from the envelope's `commit` block, and on every
-//!   migrator run from `commits.json`.
-//! - **`query_measurements`** - SQL query suite measurements (TPC-H, TPC-DS,
-//!   ClickBench, StatPopGen, PolarSignals, Fineweb, GhArchive, Public-BI).
-//!   Natural key: `(commit_sha, dataset, dataset_variant, scale_factor,
-//!   query_idx, storage, engine, format)`. Memory columns
-//!   (`peak_physical`, `peak_virtual`, `physical_delta`, `virtual_delta`)
-//!   are populated together when the run was instrumented for memory and
-//!   are NULL otherwise; the ingest path enforces "all four or none".
-//!   `dataset_variant` carries a categorical sub-name (Public-BI dataset,
-//!   ClickBench flavor); `scale_factor` is the TPC SF as a string.
-//! - **`compression_times`** - encode/decode timings from `compress-bench`.
-//!   Natural key: `(commit_sha, dataset, dataset_variant, format, op)`,
-//!   where `op ∈ {encode, decode}`. Encode and decode share a table because
-//!   they share dim and value shape; keeping them together makes the
-//!   per-format chart a single SQL query.
-//! - **`compression_sizes`** - on-disk sizes from `compress-bench`. One-shot
-//!   (no per-iteration data, no `all_runtimes_ns`). Natural key:
-//!   `(commit_sha, dataset, dataset_variant, format)`. Compression ratios
-//!   (e.g. `vortex:parquet-zstd`) are NOT stored - they are a SELECT over
-//!   this table joined to itself, computed in `api/summary.rs`.
-//! - **`random_access_times`** - take-time timings from
-//!   `random-access-bench`. Different dataset namespace from
-//!   `compression_times` (chimp, taxi, etc.) - kept in its own table so
-//!   dataset filters never have to disambiguate which suite a row belongs
-//!   to. Natural key: `(commit_sha, dataset, format)`.
-//! - **`vector_search_runs`** - cosine-similarity scans from
-//!   `vector-search-bench`. The only family that emits a timing **plus**
-//!   side counters (`matches`, `rows_scanned`, `bytes_scanned`) for the
-//!   same scan; keeping them in one row avoids a 1:N split that has to be
-//!   re-joined on read. Natural key: `(commit_sha, dataset, layout,
-//!   flavor, threshold)`. `iterations` is not part of the dim hash - it is
-//!   a side count, like `matches`.
-//!
-//! ## Column conventions
-//!
-//! - `commit_sha` is `TEXT NOT NULL` on every fact table and references the
-//!   `commits.commit_sha` PK. There is no FK constraint declared at alpha;
-//!   the ingest path upserts the commit before the records.
-//! - `value_ns` is the median per-iteration nanosecond timing for timing
-//!   tables. `value_bytes` is the on-disk byte count for `compression_sizes`.
-//! - `all_runtimes_ns BIGINT[]` carries the per-iteration timings inline.
-//!   DuckDB's list type avoids a child table; chart code only ever reads
-//!   `value_ns`, so the list is effectively cold storage today, kept for
-//!   future variance or distribution charts.
-//! - `storage` (only on `query_measurements`) is `nvme` or `s3`. Legacy `gcs`
-//!   was dropped during the v3 design pass.
-//! - `env_triple` is the `arch-os-env` host triple captured at run time
-//!   (e.g. `x86_64-linux-gnu`). Optional everywhere; useful for slicing
-//!   results by host class once the data set has more than one host class.
-//!
-//! ## Schema changes
-//!
-//! There is no migration framework. If you change the schema:
-//!
-//! 1. Update the per-family DDL constant ([`COMMITS_DDL`] for the dim,
-//!    [`QUERY_MEASUREMENTS_DDL`] / [`COMPRESSION_TIMES_DDL`] /
-//!    [`COMPRESSION_SIZES_DDL`] / [`RANDOM_ACCESS_TIMES_DDL`] /
-//!    [`VECTOR_SEARCH_RUNS_DDL`] for the facts), the matching
-//!    [`crate::records`] struct, and the [`crate::family::Family`] entry
-//!    that ties them together.
-//! 2. Update or delete any local `bench.duckdb` (the migrator's
-//!    `open_target_db` already deletes-and-recreates).
-//! 3. Bump [`SCHEMA_VERSION`] if the wire envelope's
-//!    `run_meta.schema_version` semantics change.
-//!
-//! A real forward-only migration framework is post-cutover work.
-
-/// DDL for the `commits` dim table. The five fact-table DDLs live with
-/// their respective [`crate::family::Family`] declarations; [`crate::db::open`]
-/// applies this constant first, then iterates [`crate::family::FAMILIES`].
-pub const COMMITS_DDL: &str = r#"
-CREATE TABLE IF NOT EXISTS commits (
-    commit_sha       TEXT        PRIMARY KEY NOT NULL,
-    timestamp        TIMESTAMPTZ NOT NULL,
-    message          TEXT,
-    author_name      TEXT,
-    author_email     TEXT,
-    committer_name   TEXT,
-    committer_email  TEXT,
-    tree_sha         TEXT        NOT NULL,
-    url              TEXT        NOT NULL
-);
-"#;
-
-/// DDL for the `query_measurements` fact table. Wired into the
-/// `schema_ddl` field of [`crate::family::QUERY_MEASUREMENTS`].
-pub const QUERY_MEASUREMENTS_DDL: &str = r#"
-CREATE TABLE IF NOT EXISTS query_measurements (
-    measurement_id   BIGINT      PRIMARY KEY NOT NULL,
-    commit_sha       TEXT        NOT NULL,
-    dataset          TEXT        NOT NULL,
-    dataset_variant  TEXT,
-    scale_factor     TEXT,
-    query_idx        INTEGER     NOT NULL,
-    storage          TEXT        NOT NULL,
-    engine           TEXT        NOT NULL,
-    format           TEXT        NOT NULL,
-    value_ns         BIGINT      NOT NULL,
-    all_runtimes_ns  BIGINT[]    NOT NULL,
-    peak_physical    BIGINT,
-    peak_virtual     BIGINT,
-    physical_delta   BIGINT,
-    virtual_delta    BIGINT,
-    env_triple       TEXT
-);
-"#;
-
-/// DDL for the `compression_times` fact table. Wired into the
-/// `schema_ddl` field of [`crate::family::COMPRESSION_TIMES`].
-pub const COMPRESSION_TIMES_DDL: &str = r#"
-CREATE TABLE IF NOT EXISTS compression_times (
-    measurement_id   BIGINT      PRIMARY KEY NOT NULL,
-    commit_sha       TEXT        NOT NULL,
-    dataset          TEXT        NOT NULL,
-    dataset_variant  TEXT,
-    format           TEXT        NOT NULL,
-    op               TEXT        NOT NULL,
-    value_ns         BIGINT      NOT NULL,
-    all_runtimes_ns  BIGINT[]    NOT NULL,
-    env_triple       TEXT
-);
-"#;
-
-/// DDL for the `compression_sizes` fact table. Wired into the
-/// `schema_ddl` field of [`crate::family::COMPRESSION_SIZES`].
-pub const COMPRESSION_SIZES_DDL: &str = r#"
-CREATE TABLE IF NOT EXISTS compression_sizes (
-    measurement_id   BIGINT      PRIMARY KEY NOT NULL,
-    commit_sha       TEXT        NOT NULL,
-    dataset          TEXT        NOT NULL,
-    dataset_variant  TEXT,
-    format           TEXT        NOT NULL,
-    value_bytes      BIGINT      NOT NULL
-);
-"#;
-
-/// DDL for the `random_access_times` fact table. Wired into the
-/// `schema_ddl` field of [`crate::family::RANDOM_ACCESS_TIMES`].
-pub const RANDOM_ACCESS_TIMES_DDL: &str = r#"
-CREATE TABLE IF NOT EXISTS random_access_times (
-    measurement_id   BIGINT      PRIMARY KEY NOT NULL,
-    commit_sha       TEXT        NOT NULL,
-    dataset          TEXT        NOT NULL,
-    format           TEXT        NOT NULL,
-    value_ns         BIGINT      NOT NULL,
-    all_runtimes_ns  BIGINT[]    NOT NULL,
-    env_triple       TEXT
-);
-"#;
-
-/// DDL for the `vector_search_runs` fact table. Wired into the
-/// `schema_ddl` field of [`crate::family::VECTOR_SEARCH_RUNS`].
-pub const VECTOR_SEARCH_RUNS_DDL: &str = r#"
-CREATE TABLE IF NOT EXISTS vector_search_runs (
-    measurement_id   BIGINT      PRIMARY KEY NOT NULL,
-    commit_sha       TEXT        NOT NULL,
-    dataset          TEXT        NOT NULL,
-    layout           TEXT        NOT NULL,
-    flavor           TEXT        NOT NULL,
-    threshold        DOUBLE      NOT NULL,
-    value_ns         BIGINT      NOT NULL,
-    all_runtimes_ns  BIGINT[]    NOT NULL,
-    matches          BIGINT      NOT NULL,
-    rows_scanned     BIGINT      NOT NULL,
-    bytes_scanned    BIGINT      NOT NULL,
-    iterations       INTEGER     NOT NULL,
-    env_triple       TEXT
-);
-"#;
-
-/// Schema version expected by the server. The ingest envelope's
-/// `run_meta.schema_version` must match this exactly at alpha.
-///
-/// Coupled sites that MUST agree on this value (see
-/// `benchmarks-website/AGENTS.md` → "Wire shapes are a coordinated change"):
-///
-/// - This constant.
-/// - The producer-side wire-shape source of truth in
-///   [`vortex_bench::v3`](../../../vortex-bench/src/v3.rs).
-/// - The CI ingest wrapper at `scripts/post-ingest.py`, which fills the
-///   envelope's `run_meta.schema_version` from a hardcoded Python constant.
-///   Bumping `SCHEMA_VERSION` without bumping `post-ingest.py` makes every
-///   CI run 400 at ingest until the script is updated.
-pub const SCHEMA_VERSION: i32 = 1;
-
-/// Every table in the schema, in the order a fresh boot creates them.
-/// Used by the snapshot endpoint to drive a per-table `COPY ... TO`
-/// across the whole DB and by the restore docs to document the same
-/// list. `commits` is the dim table; the rest are facts, derived from
-/// the registry so adding a new fact table is one entry in
-/// [`crate::family::FAMILIES`] and the snapshot endpoint + restore docs
-/// pick it up automatically.
-pub static TABLES: std::sync::LazyLock<Vec<&'static str>> = std::sync::LazyLock::new(|| {
-    let mut v: Vec<&'static str> = Vec::with_capacity(1 + crate::family::FAMILIES.len());
-    v.push("commits");
-    v.extend(crate::family::FAMILIES.iter().map(|f| f.table_name));
-    v
-});
diff --git a/benchmarks-website/server/src/slug.rs b/benchmarks-website/server/src/slug.rs
deleted file mode 100644
index 38bd401752f..00000000000
--- a/benchmarks-website/server/src/slug.rs
+++ /dev/null
@@ -1,222 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Opaque slugs for `/api/chart/:slug` and `/api/group/:slug`.
-//!
-//! The web-ui treats slugs as opaque strings: it receives them from
-//! `/api/groups` and feeds them back unchanged. The server is free to
-//! choose any format — slugs here are
-//! `<prefix>.<base64url-of-json>`, where `<prefix>` names the source
-//! fact table and the JSON encodes the chart or group key. Round-tripping
-//! the slug back gives a strongly-typed [`ChartKey`] or [`GroupKey`].
-
-use anyhow::Context as _;
-use anyhow::Result;
-use anyhow::anyhow;
-use base64::Engine as _;
-use base64::engine::general_purpose::URL_SAFE_NO_PAD;
-use serde::Deserialize;
-use serde::Serialize;
-
-use crate::family;
-
-// Slug prefixes live on each [`family::Family`] declaration (the
-// `chart_slug_prefix` / `group_slug_prefix` fields). `ChartKey::prefix`
-// and `GroupKey::prefix` consult the registry rather than maintaining a
-// parallel const table here; the prior `PREFIX_QUERY = "qm"` etc.
-// constants were a second source of truth that a test had to assert
-// equal-to-the-Family-entries.
-
-/// The strongly-typed chart key parsed from a slug.
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-#[serde(tag = "k")]
-pub enum ChartKey {
-    /// `query_measurements` chart: `(dataset, query_idx)` is the chart key
-    /// per [`crate::schema`]. Group context (`dataset_variant`,
-    /// `scale_factor`, `storage`) is carried alongside so the slug fully
-    /// specifies the chart.
-    QueryMeasurement {
-        dataset: String,
-        dataset_variant: Option<String>,
-        scale_factor: Option<String>,
-        storage: String,
-        query_idx: i32,
-    },
-    /// `compression_times` chart: `(dataset, dataset_variant)`.
-    CompressionTime {
-        dataset: String,
-        dataset_variant: Option<String>,
-    },
-    /// `compression_sizes` chart: `(dataset, dataset_variant)`.
-    CompressionSize {
-        dataset: String,
-        dataset_variant: Option<String>,
-    },
-    /// `random_access_times` chart: `dataset`.
-    RandomAccess { dataset: String },
-    /// `vector_search_runs` chart: `(dataset, layout, threshold)`.
-    VectorSearch {
-        dataset: String,
-        layout: String,
-        threshold: f64,
-    },
-}
-
-impl ChartKey {
-    fn prefix(&self) -> &'static str {
-        family::family_for_chart_key(self).chart_slug_prefix
-    }
-
-    /// Render the slug for this chart key.
-    pub fn to_slug(&self) -> String {
-        let json = serde_json::to_vec(self).expect("ChartKey is always JSON-serializable");
-        format!("{}.{}", self.prefix(), URL_SAFE_NO_PAD.encode(json))
-    }
-
-    /// Parse a slug previously produced by [`Self::to_slug`].
-    pub fn from_slug(slug: &str) -> Result<Self> {
-        let (_, encoded) = slug
-            .split_once('.')
-            .ok_or_else(|| anyhow!("slug missing '.' separator"))?;
-        let json = URL_SAFE_NO_PAD
-            .decode(encoded.as_bytes())
-            .context("slug payload was not valid base64url")?;
-        let key: Self = serde_json::from_slice(&json).context("slug payload was not valid JSON")?;
-        Ok(key)
-    }
-}
-
-/// Slug for a *group* of charts. Mirrors [`ChartKey`] but at the group
-/// granularity: a group is a set of charts that share every dimension except
-/// one (e.g. all 22 TPC-H queries at sf=1 on nvme).
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-#[serde(tag = "k")]
-pub enum GroupKey {
-    /// All `query_measurements` charts at one `(dataset, dataset_variant,
-    /// scale_factor, storage)`. Charts inside vary by `query_idx`.
-    QueryGroup {
-        dataset: String,
-        dataset_variant: Option<String>,
-        scale_factor: Option<String>,
-        storage: String,
-    },
-    /// Every compression-time chart (one per `(dataset, dataset_variant)`).
-    CompressionTimeGroup,
-    /// Every compression-size chart.
-    CompressionSizeGroup,
-    /// Every random-access chart.
-    RandomAccessGroup,
-    /// All vector-search charts at one `(dataset, layout)`. Charts inside
-    /// vary by `threshold`.
-    VectorSearchGroup { dataset: String, layout: String },
-}
-
-impl GroupKey {
-    fn prefix(&self) -> &'static str {
-        family::family_for_group_key(self).group_slug_prefix
-    }
-
-    /// Render the slug for this group key.
-    pub fn to_slug(&self) -> String {
-        let json = serde_json::to_vec(self).expect("GroupKey is always JSON-serializable");
-        format!("{}.{}", self.prefix(), URL_SAFE_NO_PAD.encode(json))
-    }
-
-    /// Parse a slug previously produced by [`Self::to_slug`].
-    pub fn from_slug(slug: &str) -> Result<Self> {
-        let (_, encoded) = slug
-            .split_once('.')
-            .ok_or_else(|| anyhow!("slug missing '.' separator"))?;
-        let json = URL_SAFE_NO_PAD
-            .decode(encoded.as_bytes())
-            .context("slug payload was not valid base64url")?;
-        let key: Self = serde_json::from_slice(&json).context("slug payload was not valid JSON")?;
-        Ok(key)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn roundtrip(key: ChartKey) {
-        let slug = key.to_slug();
-        let parsed = ChartKey::from_slug(&slug).expect("parses back");
-        assert_eq!(parsed, key);
-    }
-
-    #[test]
-    fn query_measurement_roundtrips() {
-        roundtrip(ChartKey::QueryMeasurement {
-            dataset: "tpch".into(),
-            dataset_variant: None,
-            scale_factor: Some("1".into()),
-            storage: "nvme".into(),
-            query_idx: 7,
-        });
-    }
-
-    #[test]
-    fn vector_search_roundtrips() {
-        roundtrip(ChartKey::VectorSearch {
-            dataset: "cohere-large-10m".into(),
-            layout: "partitioned".into(),
-            threshold: 0.75,
-        });
-    }
-
-    #[test]
-    fn random_access_roundtrips() {
-        roundtrip(ChartKey::RandomAccess {
-            dataset: "taxi".into(),
-        });
-    }
-
-    #[test]
-    fn malformed_slug_rejected() {
-        assert!(ChartKey::from_slug("not-a-slug").is_err());
-        assert!(ChartKey::from_slug("qm.****").is_err());
-    }
-
-    fn roundtrip_group(key: GroupKey) {
-        let slug = key.to_slug();
-        let parsed = GroupKey::from_slug(&slug).expect("parses back");
-        assert_eq!(parsed, key);
-    }
-
-    #[test]
-    fn group_keys_roundtrip() {
-        roundtrip_group(GroupKey::QueryGroup {
-            dataset: "tpch".into(),
-            dataset_variant: None,
-            scale_factor: Some("1".into()),
-            storage: "nvme".into(),
-        });
-        roundtrip_group(GroupKey::CompressionTimeGroup);
-        roundtrip_group(GroupKey::CompressionSizeGroup);
-        roundtrip_group(GroupKey::RandomAccessGroup);
-        roundtrip_group(GroupKey::VectorSearchGroup {
-            dataset: "cohere".into(),
-            layout: "partitioned".into(),
-        });
-    }
-
-    #[test]
-    fn group_slug_prefix_distinct_from_chart() {
-        let chart = ChartKey::CompressionTime {
-            dataset: "tpch".into(),
-            dataset_variant: None,
-        }
-        .to_slug();
-        let group = GroupKey::CompressionTimeGroup.to_slug();
-        let chart_prefix = chart.split_once('.').unwrap().0;
-        let group_prefix = group.split_once('.').unwrap().0;
-        assert_ne!(chart_prefix, group_prefix);
-    }
-
-    #[test]
-    fn malformed_group_slug_rejected() {
-        assert!(GroupKey::from_slug("not-a-slug").is_err());
-        assert!(GroupKey::from_slug("qmg.****").is_err());
-    }
-}
diff --git a/benchmarks-website/server/static/CHARTJS_PLUGIN_ZOOM_LICENSE.md b/benchmarks-website/server/static/CHARTJS_PLUGIN_ZOOM_LICENSE.md
deleted file mode 100644
index 5d0f4288b27..00000000000
--- a/benchmarks-website/server/static/CHARTJS_PLUGIN_ZOOM_LICENSE.md
+++ /dev/null
@@ -1,9 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2013-2021 chartjs-plugin-zoom contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/benchmarks-website/server/static/CHART_JS_LICENSE.md b/benchmarks-website/server/static/CHART_JS_LICENSE.md
deleted file mode 100644
index f216610fd7e..00000000000
--- a/benchmarks-website/server/static/CHART_JS_LICENSE.md
+++ /dev/null
@@ -1,9 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014-2024 Chart.js Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/benchmarks-website/server/static/chart-init.js b/benchmarks-website/server/static/chart-init.js
deleted file mode 100644
index eae6cc57662..00000000000
--- a/benchmarks-website/server/static/chart-init.js
+++ /dev/null
@@ -1,2595 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-// Hydrate Chart.js charts on /, /chart/:slug, and /group/:slug, plus the
-// lazy-fetch-on-toggle behaviour for closed `<details>` groups.
-//
-// File map (in source order):
-//   1. Constants                       — throttle delays, fetch knobs, caps.
-//   2. Canvas state contract           — every `canvas.__bench_*` field.
-//   3. Per-card DOM contract           — every `data-role` selector.
-//   4. Global filter state             — engines/formats from the navbar.
-//   5. Palette + helpers               — colours, formatting, throttle.
-//   6. Display unit picker             — bytes/time/count formatter switch.
-//   7. LTTB                            — pure largest-triangle downsampler.
-//   8. Crosshair plugin                — inline Chart.js plugin.
-//   9. External tooltip handler        — factory that returns a Chart.js
-//                                        external tooltip handler.
-//  10. Payload + datasets              — readInlinePayload, buildDatasets,
-//                                        rebuildVisibleAndUpdate.
-//  11. Full-history warmup             — ensureFullHistory,
-//                                        replaceChartPayload, plus the
-//                                        slider + downsample-badge sync
-//                                        helpers.
-//  12. Per-card construction           — constructChart.
-//  13. Range scrollbar strip           — bindRangeStrip + pointer math.
-//  14. Per-chart toolbar wiring        — bindToolbar, attachWheelPan,
-//                                        applyScope, applyY.
-//  15. Group hydration                 — bounded shard fetch queue + UI
-//                                        helpers.
-//  16. Global filter wiring            — chip toggle, URL sync, bindings.
-//  17. Per-group toolbar wiring        — group-level filter + Y override.
-//  18. Header controls                 — theme toggle, expand/collapse all.
-//  19. Page wiring                     — IntersectionObserver, init.
-//
-// Per-chart UX (for orientation):
-//   - Each `.chart-card` carries `data-chart-slug`. The card *owns* its own
-//     toolbar (`.toolbar--card`) — there is no page-level toolbar.
-//   - Landing groups fetch materialized latest-100 group shards, with bounded
-//     concurrency. Opening a group then queues `?n=all` for that group's charts
-//     so the first paint is fast but full history is already warming.
-//   - `rebuildVisibleAndUpdate` is the single source of truth for the
-//     rendered point count. The cap is one constant: at most
-//     `MAX_VISIBLE_POINTS` *unique commit indices* (x-positions) are
-//     rendered, **shared across every series**. Below the cap we render
-//     every commit that has data; above it we LTTB the per-commit
-//     "max-y across series" to pick that many representatives, then
-//     every series renders at those shared indices. This is what the
-//     cap is *supposed* to mean: visually, the chart never has more
-//     than that many x-axis columns regardless of how many lines are
-//     on it. (Earlier per-series LTTB picked different peaks for each
-//     series and the union of x-positions blew past the cap.)
-//   - The slider is throttled to ~16ms (one frame at 60fps) per v2's
-//     `CONFIG.ZOOM_THROTTLE_DELAY` so dragging the slider feels continuous.
-//   - Mouse wheel pans horizontally (chartjs-plugin-zoom does not expose
-//     pan-on-wheel, so a manual `wheel` listener calls `chart.pan(...)`).
-//   - Drag-pan + drag-rectangle-zoom are wired through the plugin and
-//     trigger the same `rebuildVisibleAndUpdate` via `onPan`/`onZoom`.
-//   - A custom inline plugin draws a vertical crosshair at the hovered
-//     commit; the external tooltip is offset and `pointer-events: none`
-//     to fix the flicker described in the per-chart UX rebuild brief.
-//
-// Canvas state contract — every per-chart property we plant on the canvas:
-//   canvas.__bench_chart              Chart.js instance, set in constructChart.
-//   canvas.__bench_payload            Last-fetched ChartResponse (raw,
-//                                     unmodified by LTTB). Source of truth
-//                                     the tooltip + LTTB rebuild read.
-//   canvas.__bench_state              { y: "linear"|"log", scope: number|"all" }
-//                                     — the per-chart toolbar state.
-//   canvas.__bench_overrides          Map<seriesLabel, true> of series the
-//                                     user has manually toggled on this card.
-//                                     Once set, the global filter no longer
-//                                     drives that label's visibility here.
-//   canvas.__bench_strip_render       Function bound by bindRangeStrip; called
-//                                     from any path that mutates scales.x.
-//   canvas.__bench_rebuild            Throttled `rebuildVisibleAndUpdate`
-//                                     wrapper; called from pan/zoom/wheel.
-//   canvas.__bench_wheel_attached     true once attachWheelPan has wired
-//                                     a wheel listener (idempotency).
-//   canvas.__bench_inline_trimmed     true if the current payload is a
-//                                     virtual latest-100 view over a longer
-//                                     full-history x-axis.
-//   canvas.__bench_full_loaded        true once a `?n=all` refetch has
-//                                     replaced the payload.
-//   canvas.__bench_full_fetch_pending true while a `?n=all` refetch is in
-//                                     flight; dedupes queue/pan promotion.
-//   canvas.__bench_full_fetch_entry   Full-history queue entry, if the fetch
-//                                     is queued but not yet complete.
-//   canvas.__bench_payload_window     The server-side commit window used for
-//                                     the current payload (`"100"` for
-//                                     shard hydration, `"all"` for warmed
-//                                     full history).
-//   canvas.__bench_display_unit       The picked display unit (`format`,
-//                                     `axisLabel`, `multiplier`) used by the
-//                                     tooltip and y-axis label. Recomputed
-//                                     after every payload swap and after each
-//                                     LTTB rebuild changes the visible window.
-//   canvas.__bench_y_user_set         true once the user has explicitly
-//                                     clicked the per-chart Y-axis toolbar.
-//                                     The per-group Y override skips charts
-//                                     where this flag is set so the local
-//                                     click stays sticky.
-//
-// Per-card DOM contract — every selector the chart cards are queried by:
-//   .chart-card[data-chart-index][data-chart-slug]    The card itself.
-//   canvas[data-chart-index]                          The chart canvas.
-//   .chart-tooltip-host                               External tooltip host.
-//   .chart-wrap                                       Canvas wrapper.
-//   [data-role="downsample-badge"]                    LTTB badge slot.
-//   [data-role="scope-slider"]                        Toolbar scope slider.
-//   .toolbar--card                                    Toolbar root.
-//   .toolbar-btn[data-y]                              Y-axis switch buttons.
-//   [data-role="range-strip"]                         Range scrollbar root.
-//   [data-role="range-window"]                        Range strip's window.
-//   [data-role="range-handle-left"]                   Left resize handle.
-//   [data-role="range-handle-right"]                  Right resize handle.
-//   .group-disclosure                                 The <details> wrapper.
-//   .group-details                                    The wrapping <section>.
-//   [data-role="global-filter-bar"]                   Filter dropdown root.
-//   [data-role="filter-trigger"]                      Filter dropdown button.
-//   [data-role="filter-panel"]                        Filter dropdown body.
-//   .filter-chip[data-filter][data-value]             A single filter chip.
-//   [data-role="filter-badge"]                        Badge on the trigger.
-//   [data-action="expand-all"]                        Header button.
-//   [data-action="collapse-all"]                      Header button.
-//   [data-role="theme-toggle"]                        Header button.
-//   #bench-filter-state                               Server-emitted filter
-//                                                     state JSON (script id).
-(function () {
-  "use strict";
-
-  // -----------------------------------------------------------------------
-  // Constants
-  // -----------------------------------------------------------------------
-  var ZOOM_THROTTLE_MS = 16;     // one frame at ~60fps for slider drag
-  var PAN_THROTTLE_MS = 50;      // pan/zoom throttle — looser than slider
-  var FETCH_N = "all";           // explicit full-history upgrade
-  var DEFAULT_VISIBLE = 100;     // initial visible window (last 100 of fetched)
-  var CHART_FETCH_N = String(DEFAULT_VISIBLE); // materialized shard window
-  var HYDRATION_CONCURRENCY = 4; // per-tab cap for latest-100 shard requests
-  var FULL_HISTORY_CONCURRENCY = 2; // per-tab cap for background `?n=all`
-  var GROUP_OPEN_PRIORITY_STEP = 100;
-  var INTERACTION_FULL_PRIORITY = 1000000;
-
-  // Resolve the default scope for a chart card. Group-open hydration always
-  // starts with the latest-100 visible window, even when the x-axis is virtual
-  // and spans the full chart history.
-  function defaultScopeForCard(_card) {
-    return DEFAULT_VISIBLE;
-  }
-  // Hard cap on how many points a single series can render at once. When
-  // the visible commit range has more raw non-null points than this, we
-  // LTTB-downsample to exactly this number; below it we render raw. So
-  // the user always sees at most this many points per series, regardless
-  // of how far they zoom out, and the rule is one sentence:
-  //
-  //   visible <= MAX_VISIBLE_POINTS  → raw
-  //   visible >  MAX_VISIBLE_POINTS  → LTTB to MAX_VISIBLE_POINTS
-  //
-  // Chart cards are ~600–900px on desktop and Chart.js draws ~2px point
-  // markers, so 500 points gives roughly 1.5px of horizontal space per
-  // point — about as dense as the eye can resolve. Bumping higher costs
-  // render time without visible improvement; lowering loses detail on
-  // wide cards.
-  var MAX_VISIBLE_POINTS = 500;
-
-  // -----------------------------------------------------------------------
-  // Global filter state (engine/format chips inside the navbar dropdown).
-  //
-  // Model:
-  //   `globalFilter.engines` / `.formats` track the *active* (visible) set
-  //   for that dimension. The chip's displayed active state mirrors
-  //   visibility — every chip active means no filter is applied, exactly
-  //   one chip inactive hides only that engine/format, and so on. The
-  //   URL `?engine=`/`?format=` stay as allowlists for stability across
-  //   refreshes; we omit the param when every chip is active (i.e. the
-  //   active set equals the universe), so the no-filter URL is clean.
-  //
-  // Per-card overrides:
-  //   Clicking a chart's legend toggles `dataset.hidden` and adds the label
-  //   to that card's `canvas.__bench_overrides` set. The global apply pass
-  //   skips overridden labels, so the user's manual call sticks even after
-  //   subsequent global filter changes.
-  // -----------------------------------------------------------------------
-  var globalFilter = readFilterState();
-  var filterUniverse = readFilterUniverseFromDom();
-  // `seedFromUrl` translates the URL state (allowlist) into the active set.
-  // Empty allowlist in the URL is treated as "no filter" → every chip
-  // active. Non-empty is taken verbatim, even if a chip has since been
-  // added or removed from the universe — keeps stale URLs deterministic.
-  seedActiveFromUrlState();
-
-  function readFilterState() {
-    var fallback = { engines: [], formats: [] };
-    var node = document.getElementById("bench-filter-state");
-    if (!node) return fallback;
-    try {
-      var parsed = JSON.parse(node.textContent);
-      return {
-        engines: Array.isArray(parsed.engines) ? parsed.engines.slice() : [],
-        formats: Array.isArray(parsed.formats) ? parsed.formats.slice() : [],
-      };
-    } catch (e) {
-      return fallback;
-    }
-  }
-
-  // Pull the chip universe straight from the rendered panel, so the JS
-  // doesn't have to mirror the server's enum. If the dropdown isn't on the
-  // page (shouldn't happen — the header always renders it when there's
-  // data) we fall back to whatever is in the URL state.
-  function readFilterUniverseFromDom() {
-    var u = { engines: [], formats: [] };
-    document.querySelectorAll(
-      '[data-role="filter-panel"] .filter-chip[data-value]:not([data-value="*"])',
-    ).forEach(function (chip) {
-      var dim = chip.getAttribute("data-filter");
-      var value = chip.getAttribute("data-value");
-      if (!dim || !value) return;
-      var bucket = dim === "engine" ? u.engines : u.formats;
-      if (bucket.indexOf(value) === -1) bucket.push(value);
-    });
-    return u;
-  }
-
-  function seedActiveFromUrlState() {
-    if (!globalFilter.engines.length) {
-      globalFilter.engines = filterUniverse.engines.slice();
-    }
-    if (!globalFilter.formats.length) {
-      globalFilter.formats = filterUniverse.formats.slice();
-    }
-  }
-
-  // Any-of-universe-missing-from-active means the dimension is filtered.
-  function dimensionIsFiltered(key) {
-    return globalFilter[key].length < filterUniverse[key].length;
-  }
-
-  // A series is hidden when its engine/format dimension is filtered AND its
-  // tag isn't in the active set. Series without an engine tag (e.g.
-  // compression-time `format:op` series) are unaffected by the engine
-  // filter — symmetric for format. This keeps the chip semantics intuitive:
-  // hiding an engine doesn't nuke charts that have no engine dimension.
-  function seriesPassesFilter(meta) {
-    if (!meta) meta = {};
-    if (meta.engine && dimensionIsFiltered("engines")
-        && globalFilter.engines.indexOf(meta.engine) === -1) {
-      return false;
-    }
-    if (meta.format && dimensionIsFiltered("formats")
-        && globalFilter.formats.indexOf(meta.format) === -1) {
-      return false;
-    }
-    return true;
-  }
-
-  // Per-group filter layer. State is a single `hiddenSeries` array of dataset
-  // labels the user has toggled off via the group's filter dropdown. Engine
-  // and format chips in the dropdown are macros: clicking them bulk-toggles
-  // every known series whose `engine`/`format` matches (see
-  // `applyMacroToHiddenSeries`). The series list itself populates as charts
-  // in the group hydrate and surface their `payload.series_meta`.
-  function seriesPassesGroupFilter(filter, label) {
-    if (!filter || !filter.hiddenSeries) return true;
-    return filter.hiddenSeries.indexOf(label) === -1;
-  }
-
-  // -----------------------------------------------------------------------
-  // Palette + helpers
-  // -----------------------------------------------------------------------
-  var palette = [
-    "#2563eb", "#dc2626", "#16a34a", "#ea580c", "#7c3aed",
-    "#0891b2", "#ca8a04", "#db2777", "#65a30d", "#475569",
-  ];
-
-  function colorFor(i) { return palette[i % palette.length]; }
-
-  function shortSha(sha) {
-    return typeof sha === "string" ? sha.slice(0, 7) : String(sha);
-  }
-
-  function shortDate(ts) {
-    if (typeof ts !== "string") return "";
-    return ts.slice(0, 10);
-  }
-
-  function truncate(s, max) {
-    if (typeof s !== "string") return "";
-    return s.length > max ? s.slice(0, max - 1) + "…" : s;
-  }
-
-  function firstLine(s) {
-    if (typeof s !== "string") return "";
-    var nl = s.indexOf("\n");
-    return nl >= 0 ? s.slice(0, nl) : s;
-  }
-
-  // Vortex commits to `develop` are squash-merged from PRs; the squash subject
-  // ends with `(#NNNN)`. Returning just the number lets callers build either a
-  // PR or commit URL.
-  function parsePrNumber(message) {
-    if (typeof message !== "string") return null;
-    var m = message.match(/\(#(\d+)\)/);
-    return m ? m[1] : null;
-  }
-
-  function escapeHtml(s) {
-    return String(s)
-      .replace(/&/g, "&amp;")
-      .replace(/</g, "&lt;")
-      .replace(/>/g, "&gt;")
-      .replace(/"/g, "&quot;")
-      .replace(/'/g, "&#39;");
-  }
-
-  // -----------------------------------------------------------------------
-  // Display unit picker. The wire payload's `unit_kind` says *what* the
-  // values are (`time_ns`, `bytes`, …); this helper turns that plus the
-  // magnitude of the loaded values into a `(multiplier, suffix, axisLabel,
-  // decimals)` tuple. The chart locks that tuple on construction (and again
-  // after the lazy `?n=all` refetch swaps the payload) so the y-axis stays
-  // stable while the user pans/zooms — recomputing per-frame would shift
-  // the unit out from under them.
-  //
-  // Worked example: a `time_ns` series whose median is 12,000,000,000 ns
-  // picks `{ multiplier: 1e-9, suffix: "s", axisLabel: "Time (s)" }`, so
-  // `12,000,000,000` renders as `12 s` on the axis and in the tooltip.
-  // -----------------------------------------------------------------------
-  var IDENTITY_UNIT = {
-    multiplier: 1,
-    suffix: "",
-    axisLabel: "",
-    decimals: 2,
-  };
-
-  // Median of finite, nonzero |v|. Zeros and NaNs aren't informative for the
-  // magnitude pick (a chart with all zeros isn't readable anyway), so we
-  // skip them; if every value is filtered out, return `null` and callers
-  // fall back to the kind's smallest display unit.
-  function magnitudeReference(values) {
-    if (!Array.isArray(values) || values.length === 0) return null;
-    var sample = [];
-    for (var i = 0; i < values.length; i++) {
-      var v = values[i];
-      if (v === null || v === undefined) continue;
-      if (typeof v !== "number" || !Number.isFinite(v)) continue;
-      var a = Math.abs(v);
-      if (a === 0) continue;
-      sample.push(a);
-    }
-    if (sample.length === 0) return null;
-    sample.sort(function (a, b) { return a - b; });
-    var mid = Math.floor(sample.length / 2);
-    return (sample.length % 2)
-      ? sample[mid]
-      : (sample[mid - 1] + sample[mid]) / 2;
-  }
-
-  // Walk every series in the loaded payload and concatenate the non-null
-  // values. The picker works off the merged distribution so a chart with one
-  // very fast and one very slow series still picks the unit that keeps the
-  // larger magnitudes readable. Toggling a series visibility via the global
-  // filter does NOT call this — the unit is locked at payload-load time.
-  function collectAllValues(payload) {
-    var out = [];
-    var series = (payload && payload.series) || {};
-    var keys = Object.keys(series);
-    for (var i = 0; i < keys.length; i++) {
-      var arr = series[keys[i]];
-      if (!Array.isArray(arr)) continue;
-      for (var j = 0; j < arr.length; j++) {
-        var v = arr[j];
-        if (v !== null && v !== undefined && Number.isFinite(v)) out.push(v);
-      }
-    }
-    return out;
-  }
-
-  function pickTimeUnit(ref) {
-    // Steps: ns → µs (1e3) → ms (1e6) → s (1e9). Pick by the median's
-    // magnitude so the y-axis tick numbers fit in 1–4 digits.
-    if (ref === null || ref < 1e3) {
-      return { multiplier: 1, suffix: "ns", decimals: 0 };
-    }
-    if (ref < 1e6) return { multiplier: 1e-3, suffix: "µs", decimals: 2 };
-    if (ref < 1e9) return { multiplier: 1e-6, suffix: "ms", decimals: 2 };
-    return { multiplier: 1e-9, suffix: "s", decimals: 2 };
-  }
-
-  function pickBytesUnit(ref) {
-    // Binary multiples to match how DuckDB and on-disk file sizes are
-    // typically reported. Steps: B → KiB (1024) → MiB → GiB → TiB.
-    var k = 1024;
-    if (ref === null || ref < k) {
-      return { multiplier: 1, suffix: "B", decimals: 0 };
-    }
-    if (ref < k * k) return { multiplier: 1 / k, suffix: "KiB", decimals: 2 };
-    if (ref < k * k * k) return { multiplier: 1 / (k * k), suffix: "MiB", decimals: 2 };
-    if (ref < k * k * k * k) return { multiplier: 1 / (k * k * k), suffix: "GiB", decimals: 2 };
-    return { multiplier: 1 / (k * k * k * k), suffix: "TiB", decimals: 2 };
-  }
-
-  function pickDisplayUnit(unitKind, values) {
-    var ref = magnitudeReference(values);
-    if (unitKind === "time_ns") {
-      var t = pickTimeUnit(ref);
-      return {
-        multiplier: t.multiplier,
-        suffix: t.suffix,
-        axisLabel: "Time (" + t.suffix + ")",
-        decimals: t.decimals,
-      };
-    }
-    if (unitKind === "bytes") {
-      var b = pickBytesUnit(ref);
-      return {
-        multiplier: b.multiplier,
-        suffix: b.suffix,
-        axisLabel: "Size (" + b.suffix + ")",
-        decimals: b.decimals,
-      };
-    }
-    if (unitKind === "throughput_mb_s") {
-      return {
-        multiplier: 1,
-        suffix: "MB/s",
-        axisLabel: "Throughput (MB/s)",
-        decimals: 2,
-      };
-    }
-    if (unitKind === "ratio" || unitKind === "count") {
-      // Dimensionless: no scaling, no suffix, no axis title — leaving the
-      // axis unlabeled keeps a "1.2× speedup" axis from being read as
-      // "1200 m" by an axis-title-driven label.
-      return {
-        multiplier: 1,
-        suffix: "",
-        axisLabel: "",
-        decimals: unitKind === "count" ? 0 : 2,
-      };
-    }
-    // Unknown kind (forward-compat with a future server enum). Identity is
-    // the safest fallback — values render verbatim, no unit.
-    return IDENTITY_UNIT;
-  }
-
-  // Tooltip formatter: applies the chart's locked display unit so the tooltip
-  // value matches the y-axis tick numbers exactly. Raw `null`/`NaN` collapse
-  // to an em-dash so a missing data point reads as a clear gap rather than
-  // a literal `0`.
-  function formatDisplayValue(rawValue, displayUnit) {
-    if (rawValue === null || rawValue === undefined || Number.isNaN(rawValue)) {
-      return "—";
-    }
-    var u = displayUnit || IDENTITY_UNIT;
-    var scaled = rawValue * u.multiplier;
-    var text = Number.isFinite(scaled) ? scaled.toFixed(u.decimals) : "—";
-    return u.suffix ? text + " " + u.suffix : text;
-  }
-
-  // Throttle to a max call rate; trailing call is preserved so the final
-  // slider position is honoured. (`requestAnimationFrame` is conceptually
-  // similar but we want a hard ceiling regardless of when the browser
-  // schedules a frame.)
-  function throttle(fn, ms) {
-    var lastRan = 0;
-    var pending = null;
-    var pendingArgs = null;
-    return function () {
-      var now = Date.now();
-      pendingArgs = arguments;
-      if (now - lastRan >= ms) {
-        lastRan = now;
-        fn.apply(null, pendingArgs);
-      } else if (!pending) {
-        var wait = ms - (now - lastRan);
-        pending = setTimeout(function () {
-          lastRan = Date.now();
-          pending = null;
-          fn.apply(null, pendingArgs);
-        }, wait);
-      }
-    };
-  }
-
-  // -----------------------------------------------------------------------
-  // LTTB (Largest-Triangle-Three-Buckets) downsampler.
-  //
-  // Returns the indices into `xs` / `ys` to keep, including index 0 and
-  // `n - 1`. `xs` must be strictly increasing. When `threshold >= n` or
-  // `threshold < 3`, returns `[0, 1, ..., n-1]` unchanged.
-  //
-  // Algorithm: <https://skemman.is/handle/1946/15343>. Per-bucket pick the
-  // point that forms the largest triangle with the previously kept point
-  // and the average of the next bucket.
-  // -----------------------------------------------------------------------
-  function lttbIndices(xs, ys, threshold) {
-    var n = xs.length;
-    if (threshold >= n || threshold < 3) {
-      var all = new Array(n);
-      for (var i = 0; i < n; i++) all[i] = i;
-      return all;
-    }
-    var out = new Array(threshold);
-    out[0] = 0;
-    var bucket = (n - 2) / (threshold - 2);
-    var a = 0;
-    for (var bi = 0; bi < threshold - 2; bi++) {
-      // Average of the *next* bucket — the "C" point in the triangle.
-      var nextStart = Math.floor((bi + 1) * bucket) + 1;
-      var nextEnd = Math.min(n, Math.floor((bi + 2) * bucket) + 1);
-      var count = Math.max(1, nextEnd - nextStart);
-      var ax = 0, ay = 0;
-      for (var j = nextStart; j < nextEnd; j++) { ax += xs[j]; ay += ys[j]; }
-      ax /= count; ay /= count;
-
-      // Search this bucket for the point with the largest triangle area
-      // against (a, avg_next).
-      var rangeStart = Math.floor(bi * bucket) + 1;
-      var rangeEnd = Math.floor((bi + 1) * bucket) + 1;
-      var pax = xs[a], pay = ys[a];
-      var maxArea = -1;
-      var maxIdx = rangeStart;
-      for (var k = rangeStart; k < rangeEnd; k++) {
-        var area = Math.abs((pax - ax) * (ys[k] - pay) - (pax - xs[k]) * (ay - pay)) * 0.5;
-        if (area > maxArea) { maxArea = area; maxIdx = k; }
-      }
-      out[bi + 1] = maxIdx;
-      a = maxIdx;
-    }
-    out[threshold - 1] = n - 1;
-    return out;
-  }
-
-  // -----------------------------------------------------------------------
-  // Crosshair plugin: draws a vertical line at the chart's active hover
-  // index. Using an inline plugin is cheaper than pulling in
-  // chartjs-plugin-crosshair, which is overkill for this one feature.
-  // -----------------------------------------------------------------------
-  var crosshairPlugin = {
-    id: "benchCrosshair",
-    afterDatasetsDraw: function (chart) {
-      var active = chart.tooltip && chart.tooltip.getActiveElements
-        ? chart.tooltip.getActiveElements()
-        : [];
-      if (!active || !active.length) return;
-      var x = active[0].element.x;
-      var ya = chart.scales && chart.scales.y;
-      if (!ya || !Number.isFinite(x)) return;
-      var ctx = chart.ctx;
-      ctx.save();
-      // `--muted` from the page theme — read it lazily so dark mode picks
-      // up the right colour.
-      var muted = getComputedStyle(document.documentElement)
-        .getPropertyValue("--muted").trim() || "#9ca3af";
-      ctx.strokeStyle = muted;
-      ctx.lineWidth = 1;
-      ctx.setLineDash([4, 4]);
-      ctx.beginPath();
-      ctx.moveTo(x, ya.top);
-      ctx.lineTo(x, ya.bottom);
-      ctx.stroke();
-      ctx.restore();
-    },
-  };
-
-  // -----------------------------------------------------------------------
-  // External tooltip with offset + flip-on-overflow.
-  //
-  // Factory contract: returns a Chart.js `external` tooltip handler closed
-  // over `canvas` (the rendered canvas element, used to read the cached
-  // payload via `canvas.__bench_payload`) and `host` (the
-  // `<div class="chart-tooltip-host">` element to render markup into;
-  // `host.parentNode` is the chart-card and is used as the positioning
-  // origin). The returned handler is invoked by Chart.js with one argument
-  // `context = { tooltip, chart }`; it mutates `host` in place and is a
-  // no-op when `tooltip.opacity === 0`.
-  //
-  // Flicker fix: the tooltip host is **always** `pointer-events: none`. The
-  // previous implementation flipped it to `auto` when visible; the cursor
-  // would land on the tooltip, fire mouseout on the canvas, the tooltip
-  // would hide, the cursor would re-enter the canvas, and the cycle would
-  // repeat at event-loop frequency. Clicks on a data point are handled by
-  // the chart's `onClick` (opens the PR or commit URL in a new tab), so the
-  // tooltip itself never needs to be interactive.
-  // -----------------------------------------------------------------------
-  function externalTooltipHandler(canvas, host) {
-    return function (context) {
-      var tt = context.tooltip;
-      if (!host) return;
-      if (tt.opacity === 0) {
-        host.style.opacity = "0";
-        return;
-      }
-
-      var chart = context.chart;
-      var payload = canvas.__bench_payload || { commits: [] };
-      var firstDp = tt.dataPoints && tt.dataPoints[0];
-      if (!firstDp) {
-        host.style.opacity = "0";
-        return;
-      }
-      // Snap to a single commit. We use `mode: "nearest"` on the chart
-      // options, so `firstDp.dataIndex` is the single closest data point
-      // to the cursor (skipping nulls in `dataset.data`). If the cursor
-      // falls between two LTTB-kept points, exactly one wins — no more
-      // rendering both columns at once.
-      var idx = firstDp.dataIndex;
-      var commit = (payload.commits || [])[idx] || {};
-      // Tooltip values must match the locked y-axis unit. Raw values still
-      // live on `dataset.rawData`; the display unit is what scales them
-      // into ms / MiB / etc. for the visible text.
-      var displayUnit = canvas.__bench_display_unit || IDENTITY_UNIT;
-      var rawLen = (chart.data.labels || []).length;
-
-      // Build one row per dataset, reading values from each series'
-      // `rawData` (the unmodified payload) so the tooltip shows raw
-      // measurements even when LTTB has nulled out `dataset.data[idx]`.
-      // Iterating `chart.data.datasets` directly — instead of mapping
-      // `tt.dataPoints` — guarantees one row per series at this single
-      // commit; `tt.dataPoints` could otherwise contain points from
-      // multiple `dataIndex` values when the cursor sits between two
-      // closely-packed LTTB columns.
-      var rowItems = chart.data.datasets.map(function (ds, dsIndex) {
-        // Skip datasets the user (or filter bar) has hidden.
-        var meta = chart.getDatasetMeta && chart.getDatasetMeta(dsIndex);
-        if (meta && meta.hidden) return null;
-        if (ds.hidden) return null;
-        var raw = (ds.rawData || [])[idx];
-        if (raw === null || raw === undefined || Number.isNaN(raw)) {
-          return null;
-        }
-        // Per-row delta is `(current - previous) / previous`, where
-        // "previous" is the chronologically preceding commit. The
-        // `commits[]` array is sorted oldest-first by SQL — index 0 is
-        // the oldest commit, the last index is the newest — so the
-        // predecessor lives at `idx - 1`. Walk further back across
-        // null-valued slots so series that didn't run on every commit
-        // still get a meaningful baseline.
-        var prevIdx = idx - 1;
-        var prevRaw = null;
-        while (prevIdx >= 0) {
-          var pv = (ds.rawData || [])[prevIdx];
-          if (pv !== null && pv !== undefined && !Number.isNaN(pv)) {
-            prevRaw = pv;
-            break;
-          }
-          prevIdx--;
-        }
-        var deltaHtml = "";
-        if (prevRaw !== null && prevRaw !== 0) {
-          var pct = ((raw - prevRaw) / prevRaw) * 100;
-          var cls = pct > 0 ? "tt-delta tt-delta--worse"
-                  : pct < 0 ? "tt-delta tt-delta--better" : "tt-delta";
-          var sign = pct > 0 ? "+" : "";
-          deltaHtml = '<span class="' + cls + '">' + sign + pct.toFixed(1) + "%</span>";
-        }
-        return {
-          label: ds.label,
-          color: ds.borderColor,
-          raw: raw,
-          deltaHtml: deltaHtml,
-        };
-      }).filter(Boolean);
-
-      // Top-to-bottom order matches the visual stack of lines at this x.
-      rowItems.sort(function (a, b) { return b.raw - a.raw; });
-
-      var rows = rowItems
-        .map(function (r) {
-          return '<div class="tt-row">'
-            + '<span class="tt-swatch" style="background:' + r.color + '"></span>'
-            + '<span class="tt-label">' + escapeHtml(r.label) + '</span>'
-            + '<span class="tt-value">'
-            + escapeHtml(formatDisplayValue(r.raw, displayUnit)) + '</span>'
-            + r.deltaHtml
-            + "</div>";
-        })
-        .join("");
-
-      // If every series was hidden / had no value at this commit, treat
-      // this as a no-op hover instead of flashing an empty popup.
-      if (!rows) {
-        host.style.opacity = "0";
-        return;
-      }
-
-      var titleHtml = '<div class="tt-title">'
-        + escapeHtml(shortSha(commit.sha)) + ' · '
-        + escapeHtml(shortDate(commit.timestamp))
-        + "</div>";
-
-      // Show short SHA + first-line commit message, truncated. The full URL
-      // (or PR URL) is wired up via the chart's onClick handler, so we don't
-      // render it as text here.
-      var msg = truncate(firstLine(commit.message || ""), 80);
-      var footerLine = commit.sha
-        ? (msg ? escapeHtml(shortSha(commit.sha)) + " · " + escapeHtml(msg)
-                : escapeHtml(shortSha(commit.sha)))
-        : escapeHtml(msg);
-      var footerHtml = footerLine
-        ? '<div class="tt-footer"><div class="tt-msg">' + footerLine + "</div></div>"
-        : "";
-
-      host.innerHTML = titleHtml + '<div class="tt-rows">' + rows + "</div>" + footerHtml;
-
-      // Position the tooltip relative to its container, offset 12px from
-      // the cursor. Flip horizontally if it would overflow.
-      var canvasRect = context.chart.canvas.getBoundingClientRect();
-      var hostRect = host.parentNode.getBoundingClientRect();
-      var x = canvasRect.left - hostRect.left + tt.caretX;
-      var y = canvasRect.top - hostRect.top + tt.caretY;
-      host.style.opacity = "1";
-      host.style.left = x + "px";
-      host.style.top = y + "px";
-      // Measure after content swap so flipping is correct.
-      var ttWidth = host.offsetWidth || 0;
-      var containerWidth = host.parentNode.clientWidth || 0;
-      var flip = (x + ttWidth + 24) > containerWidth;
-      host.style.transform = flip
-        ? "translate(calc(-100% - 12px), 12px)"
-        : "translate(12px, 12px)";
-    };
-  }
-
-  // -----------------------------------------------------------------------
-  // Payload + datasets
-  // -----------------------------------------------------------------------
-  function readInlinePayload(idx) {
-    var s = document.getElementById("chart-data-" + idx);
-    if (!s) return null;
-    try { return JSON.parse(s.textContent); } catch (e) { return null; }
-  }
-
-  function labelForCommit(commit) {
-    return commit && commit.sha ? shortSha(commit.sha) : "";
-  }
-
-  function canonicalHistory(payload) {
-    var commits = Array.isArray(payload && payload.commits) ? payload.commits : [];
-    var history = payload && payload.history ? payload.history : {};
-    var loaded = Number.isFinite(history.loaded_commits)
-      ? history.loaded_commits
-      : commits.length;
-    var total = Number.isFinite(history.total_commits)
-      ? history.total_commits
-      : commits.length;
-    var start = Number.isFinite(history.start_index) ? history.start_index : 0;
-    loaded = Math.max(0, Math.floor(loaded));
-    total = Math.max(loaded, Math.floor(total));
-    start = Math.max(0, Math.min(Math.floor(start), Math.max(0, total - loaded)));
-    return {
-      total_commits: total,
-      start_index: start,
-      loaded_commits: loaded,
-      complete: history.complete === true || (start === 0 && loaded === total),
-    };
-  }
-
-  function normalizeChartPayload(payload) {
-    if (!payload) return payload;
-    if (payload.__bench_normalized) return payload;
-    var commits = Array.isArray(payload.commits) ? payload.commits : [];
-    var history = canonicalHistory(payload);
-    if (history.complete && history.start_index === 0 && history.total_commits === commits.length) {
-      payload.history = history;
-      payload.__bench_normalized = true;
-      return payload;
-    }
-
-    var total = history.total_commits;
-    var start = history.start_index;
-    var normalizedCommits = new Array(total);
-    for (var i = 0; i < total; i++) normalizedCommits[i] = null;
-    for (var ci = 0; ci < commits.length && start + ci < total; ci++) {
-      normalizedCommits[start + ci] = commits[ci];
-    }
-
-    var rawSeries = payload.series || {};
-    var normalizedSeries = {};
-    Object.keys(rawSeries).forEach(function (name) {
-      var values = Array.isArray(rawSeries[name]) ? rawSeries[name] : [];
-      var out = new Array(total);
-      for (var zi = 0; zi < total; zi++) out[zi] = null;
-      for (var vi = 0; vi < values.length && start + vi < total; vi++) {
-        out[start + vi] = values[vi];
-      }
-      normalizedSeries[name] = out;
-    });
-
-    var clone = {};
-    Object.keys(payload).forEach(function (key) {
-      if (key !== "commits" && key !== "series") clone[key] = payload[key];
-    });
-    clone.history = history;
-    clone.commits = normalizedCommits;
-    clone.series = normalizedSeries;
-    clone.__bench_normalized = true;
-    return clone;
-  }
-
-  function rangeTouchesUnloadedHistory(payload, min, max) {
-    var history = payload && payload.history;
-    if (!history || history.complete) return false;
-    var start = history.start_index || 0;
-    var end = start + (history.loaded_commits || 0) - 1;
-    return Math.floor(min) < start || Math.ceil(max) > end;
-  }
-
-  // Build the per-series dataset shells. `data` starts as a full-length
-  // null-padded array; `rebuildVisibleAndUpdate` fills it in based on the
-  // current visible range. `rawData` holds a reference to the original
-  // payload so the tooltip can show raw values regardless of LTTB.
-  function buildDatasets(payload) {
-    var raw = payload.series || {};
-    var meta = payload.series_meta || {};
-    var n = (payload.commits || []).length;
-    var names = Object.keys(raw).sort();
-    return names.map(function (name, i) {
-      var seriesMeta = meta[name] || {};
-      var rawValues = Array.isArray(raw[name]) ? raw[name] : [];
-      // `data` starts null-padded; `rebuildVisibleAndUpdate` fills the
-      // current visible window with raw or LTTB-kept values. Chart.js's
-      // `spanGaps: true` connects the line across nulls so a series with
-      // partial coverage (a benchmark crashed at one commit, a series
-      // only runs nightly, etc.) still draws as a continuous trend
-      // through the surrounding measurements. The point markers
-      // themselves are only drawn at non-null indices, so the missing
-      // commits are visible as a "no marker" beat in the line — the line
-      // itself bridges to the next available data point.
-      var data = new Array(n);
-      for (var j = 0; j < n; j++) data[j] = null;
-      return {
-        label: name,
-        data: data,
-        rawData: rawValues,
-        borderColor: colorFor(i),
-        backgroundColor: colorFor(i) + "20",
-        borderWidth: 1.5,
-        spanGaps: true,
-        tension: 0,
-        pointRadius: 2,
-        pointHoverRadius: 5,
-        pointHitRadius: 8,
-        pointStyle: "cross",
-        // Custom field (Chart.js ignores unknown keys). Used by the global
-        // filter to decide which datasets to hide/show in bulk.
-        benchMeta: { engine: seriesMeta.engine, format: seriesMeta.format },
-        hidden: !seriesPassesFilter(seriesMeta),
-      };
-    });
-  }
-
-  // -----------------------------------------------------------------------
-  // The single source of truth for the rendered point count.
-  //
-  // Walks the visible `[rangeMin, rangeMax]` window of the raw payload and,
-  // for each series, renders raw when the visible count is at or below
-  // `MAX_VISIBLE_POINTS` and LTTB-downsamples to exactly that number when
-  // above. The result is written into `dataset.data` with nulls outside
-  // the kept set so Chart.js renders just the kept points; with
-  // `spanGaps: true`, the line connects across the nulls to the next
-  // non-null point so a sparse series still reads as a continuous trend.
-  //
-  // Mutates `dataset.data` in place to avoid GC churn on every pan frame.
-  // Updates the per-card downsample badge as a side effect.
-  // -----------------------------------------------------------------------
-  function rebuildVisibleAndUpdate(card, chart, rangeMin, rangeMax, allowFullFetch) {
-    var canvas = chart.canvas;
-    var payload = canvas.__bench_payload;
-    if (!payload) return;
-    var datasets = chart.data.datasets;
-    var n = (payload.commits || []).length;
-    if (n === 0) return;
-
-    var min = Math.max(0, Math.floor(rangeMin));
-    var max = Math.min(n - 1, Math.ceil(rangeMax));
-    if (max < min) max = min;
-
-    // Build one "virtual series" for LTTB: walk every commit index in the
-    // visible range and, for each index, take the max non-null value
-    // across all datasets. This is the union of x-positions, with a
-    // representative y per position. Series in a Vortex chart share both
-    // unit and overall scale (they're the same benchmark with different
-    // engines/formats), so max-across-series picks visually salient peaks
-    // without per-series scale skew.
-    //
-    // This becomes our LTTB input: we then pick AT MOST MAX_VISIBLE_POINTS
-    // commit indices and every dataset renders only at those shared
-    // indices. Without this, per-series LTTB picked different peaks for
-    // each series and the union of x-positions grew with the series
-    // count — visually you saw way more than MAX_VISIBLE_POINTS dots
-    // even though each line only had MAX_VISIBLE_POINTS.
-    var unionIdxs = [];
-    var unionVals = [];
-    for (var i = min; i <= max; i++) {
-      var bestY = null;
-      for (var di = 0; di < datasets.length; di++) {
-        var rawValues = datasets[di].rawData;
-        if (!Array.isArray(rawValues)) continue;
-        var v = rawValues[i];
-        if (v !== null && v !== undefined && !Number.isNaN(v)
-            && (bestY === null || v > bestY)) {
-          bestY = v;
-        }
-      }
-      if (bestY !== null) {
-        unionIdxs.push(i);
-        unionVals.push(bestY);
-      }
-    }
-
-    // Decide which commit indices to render — shared across all series.
-    var keptSet = {};
-    var anyDownsampled = false;
-    if (unionIdxs.length <= MAX_VISIBLE_POINTS) {
-      // Below the cap: render every commit that has data anywhere.
-      for (var u = 0; u < unionIdxs.length; u++) keptSet[unionIdxs[u]] = true;
-    } else {
-      // Above the cap: LTTB the union down to MAX_VISIBLE_POINTS exactly.
-      // The selected indices are then *shared* across every dataset; that
-      // is the cap's only correct interpretation of "max points on the
-      // chart at a time".
-      var localIndices = lttbIndices(unionIdxs, unionVals, MAX_VISIBLE_POINTS);
-      for (var li = 0; li < localIndices.length; li++) {
-        keptSet[unionIdxs[localIndices[li]]] = true;
-      }
-      anyDownsampled = true;
-    }
-
-    // Plant the shared kept set into every dataset.data. Series that have
-    // no value at a kept index simply remain null there; with
-    // `spanGaps: true`, the line connects to the next non-null point so
-    // a series with partial coverage (a benchmark crashed, a series only
-    // runs nightly) still draws as a continuous trend through the
-    // surrounding measurements. Markers are only drawn at non-null
-    // indices, so the gap is still visible as a missing point — just not
-    // as a broken line.
-    //
-    // We deliberately do NOT plant nearest-neighbour values for indices
-    // outside `[min, max]`: extending the line past the visible edges
-    // sounds nice (the line goes off-screen toward the next real
-    // measurement instead of stopping at the rightmost in-range point),
-    // but Chart.js's y-axis auto-scale uses every non-null value in the
-    // dataset regardless of `scales.x.min/max`. An off-screen neighbour
-    // with a very different y value (an old benchmark configuration, a
-    // first-run cold cache, anything) blows up the y-axis range and
-    // squashes the in-window values into a flat line near the floor.
-    // Fixing that would mean overriding `scales.y.min/max` per rebuild
-    // from only the in-window values, which changes the "y-axis stays
-    // stable across x-zoom" UX. Out of scope here; if a user wants to
-    // see how the line connects across the edge they can zoom out.
-    // Pull the chart's locked display-unit multiplier. Applied here, not on
-    // ingest or in the SQL, so the wire payload stays in base units (ns,
-    // bytes, …) — the unit transform is purely cosmetic.
-    var displayUnit = canvas.__bench_display_unit || IDENTITY_UNIT;
-    var multiplier = displayUnit.multiplier;
-    for (var dj = 0; dj < datasets.length; dj++) {
-      var ds = datasets[dj];
-      var dsRaw = ds.rawData;
-      if (!Array.isArray(dsRaw)) continue;
-      var data = ds.data;
-      if (!Array.isArray(data) || data.length !== n) {
-        data = new Array(n);
-        ds.data = data;
-      }
-      for (var z = 0; z < n; z++) data[z] = null;
-      for (var idxStr in keptSet) {
-        var idx = +idxStr;
-        var val = dsRaw[idx];
-        if (val !== null && val !== undefined && !Number.isNaN(val)) {
-          data[idx] = val * multiplier;
-        }
-      }
-    }
-
-    var visibleCommits = max - min + 1;
-    var keptCommits = 0;
-    for (var _u in keptSet) keptCommits++;
-    chart.update("none");
-    syncSliderFromRange(card, visibleCommits);
-    syncDownsampleBadge(card, keptCommits, visibleCommits, anyDownsampled);
-    // If the user moves into the virtual, not-yet-loaded part of the x-axis,
-    // promote this chart's queued full-history fetch. Group-open warmup should
-    // usually have it in flight already; this just puts direct interaction
-    // ahead of background work that has not started.
-    if (allowFullFetch && rangeTouchesUnloadedHistory(payload, min, max)) {
-      ensureFullHistory(card, INTERACTION_FULL_PRIORITY);
-    }
-  }
-
-  // -----------------------------------------------------------------------
-  // Full-history warmup. Opening a group queues `?n=all` for every chart in
-  // that group. Direct interaction with an unloaded virtual range promotes the
-  // same queued entry instead of issuing a duplicate request.
-  // -----------------------------------------------------------------------
-  function ensureFullHistory(card, priority) {
-    var canvas = card.querySelector("canvas");
-    if (!canvas) return Promise.resolve();
-    if (canvas.__bench_full_loaded) return Promise.resolve();
-    if (canvas.__bench_full_fetch_entry) {
-      if (priority) {
-        canvas.__bench_full_fetch_entry.priority = Math.max(
-          canvas.__bench_full_fetch_entry.priority,
-          priority
-        );
-        drainFullHistoryQueue();
-      }
-      return canvas.__bench_full_fetch_pending || Promise.resolve();
-    }
-    var slug = card.getAttribute("data-chart-slug");
-    if (!slug) return Promise.resolve();
-    var entry = scheduleFullHistory(function () {
-      var url = "/api/chart/" + encodeURIComponent(slug)
-        + "?n=" + encodeURIComponent(FETCH_N);
-      return fetch(url, { headers: { "accept": "application/json" } })
-        .then(function (r) {
-          if (r.status === 404) return null;
-          if (!r.ok) throw new Error("HTTP " + r.status);
-          return r.json();
-        })
-        .then(function (full) {
-          if (!full) return;
-          replaceChartPayload(card, full);
-          canvas.__bench_full_loaded = true;
-          canvas.__bench_inline_trimmed = false;
-          showCardLoading(card, false);
-          var group = card.closest(".group-details");
-          if (!canvas.__bench_chart && (!group || groupIsOpen(group))) {
-            fetchAndConstruct(card);
-          }
-        });
-    }, priority || 0);
-    canvas.__bench_full_fetch_entry = entry;
-    canvas.__bench_full_fetch_pending = entry.promise.catch(function (err) {
-      // Quiet — the latest-100 virtual payload is still usable. Surface to the
-      // console for debugging.
-      if (window && window.console) {
-        window.console.warn("bench: full history fetch failed", err);
-      }
-    }).then(function () {
-      canvas.__bench_full_fetch_entry = null;
-      canvas.__bench_full_fetch_pending = null;
-    });
-    return canvas.__bench_full_fetch_pending;
-  }
-
-  // Swap the chart's labels + datasets to a freshly fetched, unbounded
-  // payload while preserving the current x-range. The virtual latest-100
-  // payload and the full payload share a full-history x-axis, so the chart
-  // should not jump when the real older values arrive.
-  function replaceChartPayload(card, payload) {
-    var canvas = card.querySelector("canvas");
-    var chart = canvas && canvas.__bench_chart;
-    if (!canvas || !payload) return;
-    payload = normalizeChartPayload(payload);
-    canvas.__bench_payload = payload;
-    canvas.__bench_payload_window = FETCH_N;
-    if (!chart) return;
-    // Re-pick the display unit against the now-wider window. The first
-    // payload was the latest-100 slice; the refetch may surface older
-    // commits with a different magnitude, and we'd rather move the
-    // y-axis once at the refetch boundary than leave the chart on a
-    // stale unit. The axis title is updated to match.
-    canvas.__bench_display_unit = pickDisplayUnit(
-      payload.unit_kind, collectAllValues(payload),
-    );
-    var yAxis = chart.options.scales && chart.options.scales.y;
-    if (yAxis && yAxis.title) {
-      yAxis.title.display = !!canvas.__bench_display_unit.axisLabel;
-      yAxis.title.text = canvas.__bench_display_unit.axisLabel;
-    }
-    var newLabels = (payload.commits || []).map(labelForCommit);
-    var newDatasets = buildDatasets(payload);
-    // Re-apply per-card legend overrides + global filter to the new datasets,
-    // matching the visibility state the user had before the refetch.
-    var overrides = canvas.__bench_overrides || {};
-    for (var i = 0; i < newDatasets.length; i++) {
-      var ds = newDatasets[i];
-      if (overrides[ds.label]) {
-        // Honour any explicit legend toggle the user had made already.
-        var prev = chart.data.datasets.find(function (p) {
-          return p.label === ds.label;
-        });
-        if (prev) ds.hidden = !!prev.hidden;
-      }
-    }
-    chart.data.labels = newLabels;
-    chart.data.datasets = newDatasets;
-    // Re-evaluate per-group + global filter on the swapped dataset so the
-    // visibility state matches what was on screen before the refetch. Also
-    // refresh the group's series chip row in case the wider window surfaces
-    // a series that was absent from the inline payload.
-    applyFiltersToChart(card);
-    noteSeriesFromCard(card);
-    var newMaxIdx = Math.max(0, newLabels.length - 1);
-    var zoomLimits = chart.options.plugins
-      && chart.options.plugins.zoom
-      && chart.options.plugins.zoom.limits
-      && chart.options.plugins.zoom.limits.x;
-    if (zoomLimits) {
-      zoomLimits.max = newMaxIdx;
-    }
-    syncSliderBounds(card, newLabels.length);
-    var sx = chart.options.scales.x;
-    var prevMin = Number.isFinite(sx.min) ? sx.min : 0;
-    var prevMax = Number.isFinite(sx.max) ? sx.max : 0;
-    if (Number.isFinite(prevMin) && Number.isFinite(prevMax)) {
-      sx.min = Math.max(0, Math.min(newMaxIdx, prevMin));
-      sx.max = Math.max(sx.min, Math.min(newMaxIdx, prevMax));
-    } else {
-      var prevVisible = Math.max(1, prevMax - prevMin + 1);
-      sx.max = newMaxIdx;
-      sx.min = Math.max(0, newMaxIdx - (prevVisible - 1));
-    }
-    rebuildVisibleAndUpdate(card, chart, sx.min, sx.max);
-    if (canvas.__bench_strip_render) canvas.__bench_strip_render();
-  }
-
-  // Mirror the chart's current visible commit count onto the toolbar
-  // slider. Called from `rebuildVisibleAndUpdate` so every path that
-  // changes the visible range — toolbar slider drag, drag-pan,
-  // drag-rectangle-zoom, wheel-pan, range-strip drag — keeps the
-  // slider in sync. Programmatic value writes do not fire the slider's
-  // `input` event, so this never re-enters `applyScope`.
-  function syncSliderFromRange(card, visibleCommits) {
-    var slider = card.querySelector('[data-role="scope-slider"]');
-    if (!slider) return;
-    var lo = parseInt(slider.min, 10) || 1;
-    var hi = parseInt(slider.max, 10) || visibleCommits;
-    slider.value = String(Math.max(lo, Math.min(hi, visibleCommits)));
-  }
-
-  // Show the badge when at least one series in the visible range was
-  // downsampled. The numbers are commit counts: how many distinct
-  // commits the chart is rendering, and how many are in the visible
-  // range. Both come from the slider's mental model so "300 / 3000" in
-  // the badge matches "showing the last 3000" on the slider.
-  function syncDownsampleBadge(card, keptCommits, visibleCommits, anyDownsampled) {
-    var badge = card.querySelector('[data-role="downsample-badge"]');
-    if (!badge) return;
-    if (!anyDownsampled || keptCommits >= visibleCommits) {
-      badge.setAttribute("hidden", "");
-      badge.textContent = "";
-      return;
-    }
-    badge.removeAttribute("hidden");
-    badge.textContent = "downsampled · " + keptCommits + " / " + visibleCommits;
-    badge.setAttribute(
-      "title",
-      "Showing " + keptCommits + " of " + visibleCommits
-        + " commits in view. Each series renders at most "
-        + MAX_VISIBLE_POINTS + " points at a time; when more are in "
-        + "view, we apply LTTB (Largest Triangle, Three Buckets), an "
-        + "algorithm that picks representative points by maximising "
-        + "the area of triangles formed with neighbouring buckets. "
-        + "Visual peaks and valleys are preserved while the chart "
-        + "stays responsive. Zoom in past " + MAX_VISIBLE_POINTS
-        + " visible commits to see every raw measurement."
-    );
-  }
-
-  // -----------------------------------------------------------------------
-  // Per-card construction. The set of `canvas.__bench_*` fields planted
-  // by this function (and read elsewhere) is documented at the top of
-  // this file under "Canvas state contract".
-  // -----------------------------------------------------------------------
-  function constructChart(card) {
-    var idx = card.getAttribute("data-chart-index");
-    var canvas = card.querySelector('canvas[data-chart-index="' + idx + '"]');
-    if (!canvas || typeof Chart === "undefined") return null;
-    if (canvas.__bench_chart) return canvas.__bench_chart;
-
-    var payload = normalizeChartPayload(canvas.__bench_payload || readInlinePayload(idx));
-    if (!payload) return null;
-    canvas.__bench_payload = payload;
-    // Latest-100 payloads are normalized onto the full x-axis. `history`
-    // tells us whether old indices are virtual placeholders or real data.
-    if (canvas.__bench_full_loaded === undefined) {
-      var history = canonicalHistory(payload);
-      canvas.__bench_full_loaded = !!history.complete;
-      canvas.__bench_inline_trimmed = !canvas.__bench_full_loaded;
-    }
-
-    var state = canvas.__bench_state
-      || { y: "linear", scope: defaultScopeForCard(card) };
-    canvas.__bench_state = state;
-    // Series labels the user has explicitly toggled on this card. Once a
-    // label lands here, the global filter no longer drives that series's
-    // hidden-state on this card — only direct legend clicks do.
-    if (!canvas.__bench_overrides) canvas.__bench_overrides = {};
-    // Lock the display unit for the lifetime of this loaded payload. We
-    // recompute only when `replaceChartPayload` swaps in a wider window
-    // after a `?n=all` refetch — toggling a series via the global filter
-    // never touches it. See `pickDisplayUnit` for the full rationale.
-    canvas.__bench_display_unit = pickDisplayUnit(
-      payload.unit_kind, collectAllValues(payload),
-    );
-
-    var labels = (payload.commits || []).map(labelForCommit);
-    var datasets = buildDatasets(payload);
-    var host = card.querySelector(".chart-tooltip-host");
-    var range = visibleRange(labels.length, state.scope);
-    var legendPosition = (window.matchMedia
-      && window.matchMedia("(max-width: 768px)").matches) ? "top" : "bottom";
-
-    // Throttled rebuild for pan/zoom. Both axes mutate scales.x.min/max
-    // continuously during interaction, so we re-derive the rendered
-    // points on every frame (capped to PAN_THROTTLE_MS) and refresh the
-    // range strip to match. Single throttle so LTTB and the strip never
-    // diverge.
-    var throttledRebuild = throttle(function (chart) {
-      var sx = chart.scales && chart.scales.x;
-      if (!sx) return;
-      rebuildVisibleAndUpdate(card, chart, sx.min, sx.max, true);
-      if (canvas.__bench_strip_render) canvas.__bench_strip_render();
-    }, PAN_THROTTLE_MS);
-
-    var chart = new Chart(canvas, {
-      type: "line",
-      data: { labels: labels, datasets: datasets },
-      plugins: [crosshairPlugin],
-      options: {
-        responsive: true,
-        maintainAspectRatio: false,
-        animation: false,
-        // Snap to the single nearest commit *that has rendered data*.
-        // After LTTB downsampling most commit indices are null in
-        // `dataset.data`; `mode: "index"` would happily pick one of
-        // those null indices and produce an empty tooltip, while
-        // `mode: "x"` would pick multiple closely-packed LTTB columns
-        // at once and the tooltip would render duplicate rows for the
-        // same series at different commits. `mode: "nearest"` returns
-        // exactly one closest data point — its `dataIndex` is then
-        // used by the external handler as the single hovered commit,
-        // and the handler iterates `chart.data.datasets` itself to
-        // build one row per series. `intersect: false` keeps it
-        // active anywhere on the chart and, combined with
-        // `pointer-events: none` on the tooltip host, is also the
-        // flicker fix.
-        interaction: { mode: "nearest", intersect: false, axis: "x" },
-        onClick: function (event, _activeElements, chart) {
-          var points = chart.getElementsAtEventForMode(
-            event, "nearest", { intersect: false, axis: "x" }, true,
-          );
-          if (!points.length) return;
-          var pIdx = points[0].index;
-          var commits = (canvas.__bench_payload || {}).commits || [];
-          var commit = commits[pIdx];
-          if (!commit) return;
-          var pr = parsePrNumber(commit.message);
-          var url = pr
-            ? "https://github.com/vortex-data/vortex/pull/" + pr
-            : commit.url;
-          if (url) window.open(url, "_blank", "noopener");
-        },
-        scales: {
-          y: {
-            type: state.y === "log" ? "logarithmic" : "linear",
-            beginAtZero: state.y !== "log",
-            // Axis title reflects the locked display unit. Empty string when
-            // the kind is dimensionless (`ratio`, `count`) so a "1.2× speedup"
-            // chart doesn't get an arbitrary "value" label and a "12 m" chart
-            // doesn't get read as anything other than `12 ms` / `12 s` / etc.
-            title: {
-              display: !!canvas.__bench_display_unit.axisLabel,
-              text: canvas.__bench_display_unit.axisLabel,
-            },
-          },
-          x: {
-            min: range.min,
-            max: range.max,
-            title: { display: false },
-            // With a 5000-commit history rendering one tick per commit
-            // is unreadable anyway. Cap it; Chart.js will pick a sensible
-            // subset of label indices to draw.
-            ticks: { maxTicksLimit: 12, autoSkip: true },
-          },
-        },
-        plugins: {
-          legend: {
-            position: legendPosition,
-            // Wrap the default toggle so we record the per-card override
-            // and keep `dataset.hidden` in sync with the legend's
-            // `_hiddenInLegend` flag — the global filter pass writes to
-            // `dataset.hidden`, so they need to track each other or
-            // subsequent global changes look stale.
-            onClick: function (e, item, legend) {
-              var ci = legend.chart;
-              var ds = ci.data.datasets[item.datasetIndex];
-              var label = ds && ds.label;
-              if (label && ci.canvas && ci.canvas.__bench_overrides) {
-                ci.canvas.__bench_overrides[label] = true;
-              }
-              var visible = ci.isDatasetVisible(item.datasetIndex);
-              ci.setDatasetVisibility(item.datasetIndex, !visible);
-              if (ds) ds.hidden = visible; // flipped: was visible → now hidden, etc.
-              ci.update();
-            },
-          },
-          tooltip: {
-            enabled: false,
-            external: externalTooltipHandler(canvas, host),
-            // Row ordering is handled inside the external handler now —
-            // we iterate `chart.data.datasets` ourselves rather than the
-            // tooltip's `dataPoints`, so `itemSort` here would be dead
-            // code.
-          },
-          // chartjs-plugin-zoom config — wheel-zoom is disabled because we
-          // want wheel-pan instead (handled by the canvas wheel listener
-          // below). Drag-pan and drag-rectangle-zoom are free.
-          zoom: {
-            zoom: {
-              wheel: { enabled: false },
-              drag: {
-                enabled: true,
-                backgroundColor: "rgba(37, 99, 235, 0.10)",
-              },
-              mode: "x",
-              onZoom: function (ctx) { throttledRebuild(ctx.chart); },
-            },
-            pan: {
-              enabled: true,
-              mode: "x",
-              modifierKey: null,
-              onPan: function (ctx) { throttledRebuild(ctx.chart); },
-            },
-            limits: {
-              x: { min: 0, max: Math.max(0, labels.length - 1), minRange: 4 },
-            },
-          },
-        },
-      },
-    });
-
-    canvas.__bench_chart = chart;
-    canvas.__bench_rebuild = throttledRebuild;
-    attachWheelPan(canvas, chart, throttledRebuild);
-    syncSliderBounds(card, labels.length);
-    // Initial render: the chart is constructed with empty (null) data;
-    // populate it for the initial visible window. Strip is bound after the
-    // rebuild so its first paint reflects the same range Chart.js shows.
-    rebuildVisibleAndUpdate(card, chart, range.min, range.max);
-    bindRangeStrip(card, chart);
-    if (canvas.__bench_strip_render) canvas.__bench_strip_render();
-    // `buildDatasets` seeded `hidden` from the global filter; reapply through
-    // the layered helper so a per-group filter set before this card hydrated
-    // also takes effect. Then surface this card's series labels to the
-    // group's filter dropdown so the chip row picks them up.
-    applyFiltersToChart(card);
-    noteSeriesFromCard(card);
-    return chart;
-  }
-
-  // -----------------------------------------------------------------------
-  // Range scrollbar strip — the thin track below each canvas. Spans the full
-  // commit history; the highlighted "window" matches the chart's currently
-  // visible x-range and can be dragged or its edges resized to pan/zoom.
-  // -----------------------------------------------------------------------
-  function bindRangeStrip(card, chart) {
-    var strip = card.querySelector('[data-role="range-strip"]');
-    if (!strip || strip.__bench_bound) return;
-    strip.__bench_bound = true;
-    var win = strip.querySelector('[data-role="range-window"]');
-    var leftHandle = strip.querySelector('[data-role="range-handle-left"]');
-    var rightHandle = strip.querySelector('[data-role="range-handle-right"]');
-    if (!win || !leftHandle || !rightHandle) return;
-
-    var canvas = card.querySelector("canvas");
-
-    function commitCount() {
-      return (chart.data.labels || []).length;
-    }
-
-    function visibleBounds() {
-      var n = commitCount();
-      if (n <= 0) return { min: 0, max: 0 };
-      var maxIdx = n - 1;
-      var sx = chart.options.scales.x || {};
-      var min = Number.isFinite(sx.min) ? sx.min : 0;
-      var max = Number.isFinite(sx.max) ? sx.max : maxIdx;
-      min = Math.max(0, Math.min(maxIdx, min));
-      max = Math.max(min, Math.min(maxIdx, max));
-      return { min: min, max: max };
-    }
-
-    function render() {
-      var n = commitCount();
-      if (n <= 0) {
-        win.style.left = "0%";
-        win.style.width = "100%";
-        return;
-      }
-      var b = visibleBounds();
-      var span = Math.max(1, n - 1);
-      var leftPct = (b.min / span) * 100;
-      var widthPct = ((b.max - b.min) / span) * 100;
-      // A minimum visible width keeps the handles grabbable when zoomed in
-      // tight on a single commit.
-      if (widthPct < 1.5) widthPct = 1.5;
-      if (leftPct + widthPct > 100) leftPct = 100 - widthPct;
-      win.style.left = leftPct + "%";
-      win.style.width = widthPct + "%";
-    }
-
-    function setRange(newMin, newMax) {
-      var n = commitCount();
-      if (n <= 0) return;
-      var maxIdx = n - 1;
-      var minRange = 1; // matches plugin `limits.x.minRange = 4` loosely; allow tighter via strip
-      newMin = Math.max(0, Math.min(maxIdx - minRange, newMin));
-      newMax = Math.max(newMin + minRange, Math.min(maxIdx, newMax));
-      chart.options.scales.x.min = newMin;
-      chart.options.scales.x.max = newMax;
-      // Track scope on the canvas so the toolbar slider stays consistent
-      // when the user later drags it.
-      if (canvas && canvas.__bench_state) {
-        canvas.__bench_state.scope = Math.round(newMax - newMin + 1);
-      }
-      // Re-derive what Chart.js renders against the new visible window.
-      // `rebuildVisibleAndUpdate` calls `chart.update("none")`, applies
-      // LTTB, and mirrors the new scope onto the toolbar slider, so the
-      // strip-driven pan/resize stays in lockstep with both the data
-      // density and the slider readout.
-      rebuildVisibleAndUpdate(card, chart, newMin, newMax, true);
-      render();
-    }
-
-    function pxToIndex(px, trackWidth) {
-      var n = commitCount();
-      if (n <= 1 || trackWidth <= 0) return 0;
-      var pct = Math.max(0, Math.min(1, px / trackWidth));
-      return pct * (n - 1);
-    }
-
-    var dragState = null;
-
-    function onPointerDown(e) {
-      if (e.button !== undefined && e.button !== 0) return;
-      var role = e.target.getAttribute && e.target.getAttribute("data-role");
-      var rect = strip.getBoundingClientRect();
-      var trackWidth = rect.width;
-      var b = visibleBounds();
-      var idxAtCursor = pxToIndex(e.clientX - rect.left, trackWidth);
-
-      var mode;
-      if (role === "range-handle-left") mode = "resize-left";
-      else if (role === "range-handle-right") mode = "resize-right";
-      else if (role === "range-window") mode = "pan";
-      else {
-        // Click on bare track: jump the window so its centre lands at the
-        // cursor, then begin a pan drag.
-        var width = b.max - b.min;
-        var newMin = idxAtCursor - width / 2;
-        setRange(newMin, newMin + width);
-        b = visibleBounds();
-        mode = "pan";
-      }
-      dragState = {
-        mode: mode,
-        rect: rect,
-        startX: e.clientX,
-        startMin: b.min,
-        startMax: b.max,
-        pointerId: e.pointerId,
-      };
-      try { strip.setPointerCapture(e.pointerId); } catch (err) {}
-      e.preventDefault();
-      strip.classList.add("chart-range-strip--dragging");
-    }
-
-    function onPointerMove(e) {
-      if (!dragState) return;
-      var n = commitCount();
-      if (n <= 1) return;
-      var trackWidth = dragState.rect.width;
-      var dxPx = e.clientX - dragState.startX;
-      var dxIdx = (dxPx / Math.max(1, trackWidth)) * (n - 1);
-      if (dragState.mode === "pan") {
-        setRange(dragState.startMin + dxIdx, dragState.startMax + dxIdx);
-      } else if (dragState.mode === "resize-left") {
-        setRange(dragState.startMin + dxIdx, dragState.startMax);
-      } else if (dragState.mode === "resize-right") {
-        setRange(dragState.startMin, dragState.startMax + dxIdx);
-      }
-    }
-
-    function onPointerUp(e) {
-      if (!dragState) return;
-      try { strip.releasePointerCapture(dragState.pointerId); } catch (err) {}
-      dragState = null;
-      strip.classList.remove("chart-range-strip--dragging");
-    }
-
-    strip.addEventListener("pointerdown", onPointerDown);
-    strip.addEventListener("pointermove", onPointerMove);
-    strip.addEventListener("pointerup", onPointerUp);
-    strip.addEventListener("pointercancel", onPointerUp);
-
-    // Expose the strip's render function so other code paths (toolbar
-    // slider, wheel-pan, the throttled LTTB rebuild) can keep the strip
-    // in lockstep without each having to know strip internals. The chart
-    // options' `onPan` / `onZoom` callbacks call this via the throttled
-    // rebuild rather than overriding them here, so LTTB and the strip
-    // refresh as one unit.
-    canvas.__bench_strip_render = render;
-    render();
-  }
-
-  // Cap the toolbar slider's `max` to the chart's full x-axis length. For a
-  // latest-100 virtual payload this is intentionally larger than the loaded
-  // point count, so "Show all" can expose the unloaded older range while the
-  // full-history fetch is warming.
-  function syncSliderBounds(card, commitCount) {
-    var slider = card.querySelector('[data-role="scope-slider"]');
-    if (!slider) return;
-    var max = Math.max(5, commitCount);
-    slider.max = String(max);
-    // Pick a step that gives ~200 stops across the slider so dragging
-    // feels continuous regardless of history size.
-    var step = Math.max(1, Math.round(max / 200));
-    slider.step = String(step);
-    var current = parseInt(slider.value, 10);
-    if (!Number.isFinite(current) || current > max) {
-      var def = defaultScopeForCard(card);
-      var seed = def === "all" ? max : Math.min(def, max);
-      slider.value = String(seed);
-    }
-  }
-
-  // Wheel = horizontal pan. Chart.js zoom plugin doesn't support wheel-pan
-  // out of the box (wheel is always zoom in its config), so we attach a
-  // `wheel` listener that translates `deltaY`/`deltaX` into `chart.pan` and
-  // re-runs the rebuild after panning.
-  function attachWheelPan(canvas, chart, rebuild) {
-    if (canvas.__bench_wheel_attached) return;
-    canvas.__bench_wheel_attached = true;
-    canvas.addEventListener("wheel", function (e) {
-      // Treat horizontal-wheel-or-shift+wheel as horizontal pan; otherwise
-      // also pan on plain vertical wheel so trackpad scroll-up/down moves
-      // through commit history without needing modifier keys.
-      var dx = (Math.abs(e.deltaX) > Math.abs(e.deltaY)) ? e.deltaX : e.deltaY;
-      if (!dx) return;
-      e.preventDefault();
-      // Browser wheel-down reports a positive delta. In Chart.js pan space,
-      // positive x moves the visible window toward older commits, while
-      // negative x moves back toward newer commits.
-      chart.pan({ x: dx * 0.5 }, undefined, "none");
-      // `rebuild` recomputes LTTB on the new visible range AND, via the
-      // throttled wrapper, also calls `canvas.__bench_strip_render`.
-      rebuild(chart);
-    }, { passive: false });
-  }
-
-  // -----------------------------------------------------------------------
-  // Recompute helpers driven by the per-chart toolbar.
-  // -----------------------------------------------------------------------
-  // Invariant: when `currentRange` is supplied AND the chart is already
-  // panned away from the right edge, a scope change preserves the visible
-  // CENTER instead of snapping to the most recent N commits. With no
-  // `currentRange` (initial render) or a view that already covers
-  // everything / sits flush with the newest commit, anchor to the right —
-  // the right default at first load and after "show all".
-  function visibleRange(commitCount, scope, currentRange) {
-    if (commitCount <= 0) return { min: undefined, max: undefined };
-    var maxIdx = commitCount - 1;
-    if (scope === "all" || !Number.isFinite(scope) || scope <= 0 || scope >= commitCount) {
-      return { min: 0, max: maxIdx };
-    }
-    var width = scope;
-    var rightAnchored = { min: Math.max(0, maxIdx - (width - 1)), max: maxIdx };
-    if (!currentRange) return rightAnchored;
-    var curMin = Number.isFinite(currentRange.min) ? currentRange.min : 0;
-    var curMax = Number.isFinite(currentRange.max) ? currentRange.max : maxIdx;
-    var coversAll = curMin <= 0 && curMax >= maxIdx;
-    // Half-commit tolerance: pan/zoom can leave fractional drift even when
-    // the user is effectively still flush with the newest commit.
-    var atRightEdge = curMax >= maxIdx - 0.5;
-    if (coversAll || atRightEdge) return rightAnchored;
-    var center = (curMin + curMax) / 2;
-    var halfWidth = (width - 1) / 2;
-    var newMin = Math.round(center - halfWidth);
-    var newMax = newMin + (width - 1);
-    if (newMin < 0) {
-      newMin = 0;
-      newMax = width - 1;
-    } else if (newMax > maxIdx) {
-      newMax = maxIdx;
-      newMin = maxIdx - (width - 1);
-    }
-    return { min: newMin, max: newMax };
-  }
-
-  function applyScope(card, scopeValue) {
-    var canvas = card.querySelector("canvas");
-    var chart = canvas && canvas.__bench_chart;
-    if (!chart) return;
-    var commits = chart.data.labels.length;
-    var scope = scopeValue === "all" ? "all" : parseInt(scopeValue, 10);
-    canvas.__bench_state.scope = scope;
-    // Capture the chart's existing visible window BEFORE we overwrite it,
-    // so `visibleRange` can preserve the center when the user has panned
-    // away from the right edge.
-    var sx = chart.options.scales.x;
-    var currentRange = sx ? { min: sx.min, max: sx.max } : null;
-    var range = visibleRange(commits, scope, currentRange);
-    chart.options.scales.x.min = range.min;
-    chart.options.scales.x.max = range.max;
-    rebuildVisibleAndUpdate(card, chart, range.min, range.max, true);
-    syncToolbarUi(card, "scope", String(scopeValue));
-    if (canvas.__bench_strip_render) canvas.__bench_strip_render();
-  }
-
-  // `userInitiated` defaults to true. Once set, the chart is "sticky" — the
-  // per-group Y apply pass skips it on subsequent group-level clicks,
-  // honouring the user's explicit per-card choice. The per-group toolbar
-  // passes `false` so it doesn't pollute the flag while broadcasting.
-  function applyY(card, yValue, userInitiated) {
-    var canvas = card.querySelector("canvas");
-    var chart = canvas && canvas.__bench_chart;
-    if (!chart) return;
-    if (userInitiated !== false) {
-      canvas.__bench_y_user_set = true;
-    }
-    canvas.__bench_state.y = yValue;
-    chart.options.scales.y.type = yValue === "log" ? "logarithmic" : "linear";
-    chart.options.scales.y.beginAtZero = yValue !== "log";
-    chart.update("none");
-    syncToolbarUi(card, "y", yValue);
-  }
-
-  function syncToolbarUi(card, group, value) {
-    var attr = "data-" + group;
-    card.querySelectorAll(".toolbar-btn[" + attr + "]").forEach(function (b) {
-      b.classList.toggle("toolbar-btn--active", b.getAttribute(attr) === value);
-    });
-    if (group === "scope") {
-      var slider = card.querySelector('[data-role="scope-slider"]');
-      if (slider && /^\d+$/.test(value)) slider.value = value;
-    }
-  }
-
-  function bindToolbar(card) {
-    var toolbar = card.querySelector(".toolbar--card");
-    if (!toolbar || toolbar.__bench_bound) return;
-    toolbar.__bench_bound = true;
-
-    toolbar.addEventListener("click", function (e) {
-      var btn = e.target.closest(".toolbar-btn");
-      if (!btn || !toolbar.contains(btn)) return;
-      if (btn.hasAttribute("data-y")) applyY(card, btn.getAttribute("data-y"));
-    });
-
-    var slider = toolbar.querySelector('[data-role="scope-slider"]');
-    if (slider) {
-      // `input` (continuous), throttled so dragging stays at ~60fps even on
-      // pages with dozens of charts. Last value still lands because
-      // `throttle` preserves the trailing call.
-      var throttled = throttle(function () {
-        applyScope(card, slider.value);
-      }, ZOOM_THROTTLE_MS);
-      slider.addEventListener("input", throttled);
-    }
-  }
-
-  // -----------------------------------------------------------------------
-  // Group hydration. Every landing group renders chart shells with versioned
-  // shard metadata. On intent or first open we fetch materialized latest-100
-  // group shards through a small per-tab queue and construct each chart as
-  // soon as its shard arrives.
-  // -----------------------------------------------------------------------
-  var hydrationActive = 0;
-  var hydrationQueue = [];
-  var fullHistoryActive = 0;
-  var fullHistoryQueue = [];
-  var groupOpenPriority = 0;
-
-  function scheduleHydration(task, priority) {
-    var entry = {
-      task: task,
-      priority: priority || 0,
-      promise: null,
-      resolve: null,
-      reject: null,
-    };
-    entry.promise = new Promise(function (resolve, reject) {
-      entry.resolve = resolve;
-      entry.reject = reject;
-    });
-    hydrationQueue.push(entry);
-    drainHydrationQueue();
-    return entry;
-  }
-
-  function drainHydrationQueue() {
-    while (hydrationActive < HYDRATION_CONCURRENCY && hydrationQueue.length) {
-      hydrationQueue.sort(function (a, b) { return b.priority - a.priority; });
-      var item = hydrationQueue.shift();
-      hydrationActive++;
-      Promise.resolve()
-        .then(item.task)
-        .then(
-          function (value) {
-            hydrationActive--;
-            item.resolve(value);
-            drainHydrationQueue();
-          },
-          function (err) {
-            hydrationActive--;
-            item.reject(err);
-            drainHydrationQueue();
-          }
-        );
-    }
-  }
-
-  function scheduleFullHistory(task, priority) {
-    var entry = {
-      task: task,
-      priority: priority || 0,
-      promise: null,
-      resolve: null,
-      reject: null,
-    };
-    entry.promise = new Promise(function (resolve, reject) {
-      entry.resolve = resolve;
-      entry.reject = reject;
-    });
-    fullHistoryQueue.push(entry);
-    drainFullHistoryQueue();
-    return entry;
-  }
-
-  function drainFullHistoryQueue() {
-    while (fullHistoryActive < FULL_HISTORY_CONCURRENCY && fullHistoryQueue.length) {
-      fullHistoryQueue.sort(function (a, b) { return b.priority - a.priority; });
-      var item = fullHistoryQueue.shift();
-      fullHistoryActive++;
-      Promise.resolve()
-        .then(item.task)
-        .then(
-          function (value) {
-            fullHistoryActive--;
-            item.resolve(value);
-            drainFullHistoryQueue();
-          },
-          function (err) {
-            fullHistoryActive--;
-            item.reject(err);
-            drainFullHistoryQueue();
-          }
-        );
-    }
-  }
-
-  function priorityForGroupOpen(group) {
-    groupOpenPriority += GROUP_OPEN_PRIORITY_STEP;
-    group.__bench_group_priority = groupOpenPriority;
-    return groupOpenPriority;
-  }
-
-  function fetchAndConstruct(card) {
-    var canvas = card.querySelector("canvas");
-    if (!canvas) return Promise.resolve();
-    if (canvas.__bench_chart) return Promise.resolve();
-    if (constructChart(card)) {
-      bindToolbar(card);
-    }
-    return Promise.resolve();
-  }
-
-  function groupCards(group) {
-    return Array.prototype.slice.call(
-      group.querySelectorAll(".chart-card[data-chart-slug]")
-    );
-  }
-
-  function cardHasPayloadAvailable(card) {
-    var canvas = card.querySelector("canvas");
-    if (!canvas) return true;
-    if (canvas.__bench_payload) return true;
-    var idx = card.getAttribute("data-chart-index");
-    return idx != null && !!readInlinePayload(idx);
-  }
-
-  function groupShardCount(group) {
-    var n = parseInt(group.getAttribute("data-group-shard-count") || "0", 10);
-    return Number.isFinite(n) && n > 0 ? n : 0;
-  }
-
-  function groupShardPrefix(group) {
-    return group.getAttribute("data-group-shard-prefix") || "";
-  }
-
-  function groupShardUrl(group, index) {
-    var prefix = groupShardPrefix(group);
-    return prefix ? prefix + encodeURIComponent(String(index)) : "";
-  }
-
-  function groupHydrationState(group) {
-    if (!group.__bench_group_hydration) {
-      group.__bench_group_hydration = {
-        loaded: {},
-        pending: {},
-        entries: {},
-        errors: {},
-      };
-    }
-    return group.__bench_group_hydration;
-  }
-
-  function cardBySlug(group, slug) {
-    var cards = groupCards(group);
-    for (var i = 0; i < cards.length; i++) {
-      if (cards[i].getAttribute("data-chart-slug") === slug) return cards[i];
-    }
-    return null;
-  }
-
-  function showCardLoading(card, on) {
-    var existing = card.querySelector(".chart-loading");
-    if (on) {
-      if (existing) return;
-      var el = document.createElement("div");
-      el.className = "chart-loading";
-      el.textContent = "loading…";
-      card.appendChild(el);
-    } else if (existing) {
-      existing.remove();
-    }
-  }
-
-  function showCardError(card, msg) {
-    var existing = card.querySelector(".chart-error");
-    if (existing) existing.remove();
-    var el = document.createElement("div");
-    el.className = "chart-error";
-    el.textContent = msg;
-    card.appendChild(el);
-    setTimeout(function () { if (el.parentNode) el.remove(); }, 4000);
-  }
-
-  function applyGroupShard(group, shard) {
-    if (!shard || !Array.isArray(shard.charts)) return;
-    shard.charts.forEach(function (payload) {
-      if (!payload || !payload.slug) return;
-      var card = cardBySlug(group, payload.slug);
-      var canvas = card && card.querySelector("canvas");
-      if (!canvas) return;
-      if (!canvas.__bench_full_loaded) {
-        canvas.__bench_payload = normalizeChartPayload(payload);
-        canvas.__bench_payload_window = CHART_FETCH_N;
-      }
-      showCardLoading(card, false);
-      if (groupIsOpen(group)) fetchAndConstruct(card);
-    });
-  }
-
-  function fetchGroupShard(group, index, priority) {
-    var state = groupHydrationState(group);
-    if (state.loaded[index]) return Promise.resolve();
-    if (state.pending[index]) {
-      if (state.entries[index] && priority) {
-        state.entries[index].priority = Math.max(state.entries[index].priority, priority);
-        drainHydrationQueue();
-      }
-      return state.pending[index];
-    }
-    var url = groupShardUrl(group, index);
-    if (!url) return Promise.resolve();
-    var entry = scheduleHydration(function () {
-      return fetch(url, { headers: { "accept": "application/json" } })
-        .then(function (r) {
-          if (r.status === 404) throw new Error("not found");
-          if (!r.ok) throw new Error("HTTP " + r.status);
-          return r.json();
-        })
-        .then(function (payload) {
-          state.loaded[index] = true;
-          state.errors[index] = null;
-          applyGroupShard(group, payload);
-        });
-    }, priority);
-    state.entries[index] = entry;
-    state.pending[index] = entry.promise.catch(function (err) {
-      state.errors[index] = err;
-      if (index === 0) {
-        groupCards(group).forEach(function (card) {
-          if (!cardHasPayloadAvailable(card)) {
-            showCardLoading(card, false);
-            showCardError(card, "failed to load: " + (err.message || "unknown error"));
-          }
-        });
-      }
-    }).then(function () {
-      state.pending[index] = null;
-      state.entries[index] = null;
-    });
-    return state.pending[index];
-  }
-
-  function groupIsOpen(group) {
-    var details = group.querySelector("details.group-disclosure");
-    return !details || details.open;
-  }
-
-  function queueRemainingGroupShards(group, priority) {
-    var count = groupShardCount(group);
-    for (var i = 1; i < count; i++) fetchGroupShard(group, i, priority || 0);
-  }
-
-  function queueGroupFullHistory(group, priority) {
-    groupCards(group).forEach(function (card) {
-      ensureFullHistory(card, priority || 0);
-    });
-  }
-
-  function hydrateGroupShardZero(group, showLoading, priority) {
-    if (showLoading) {
-      groupCards(group).forEach(function (card) {
-        if (!cardHasPayloadAvailable(card)) showCardLoading(card, true);
-      });
-    }
-    return fetchGroupShard(group, 0, priority || (showLoading ? 1 : 0)).then(function () {
-      if (showLoading) {
-        groupCards(group).forEach(function (card) {
-          if (cardHasPayloadAvailable(card)) showCardLoading(card, false);
-        });
-      }
-    });
-  }
-
-  function hydrateOpenGroup(disclosure) {
-    if (!disclosure || !disclosure.open) return;
-    var group = disclosure.closest(".group-details");
-    if (!group) return;
-    var priority = priorityForGroupOpen(group);
-    hydrateGroupShardZero(group, true, priority + 20).then(function () {
-      queueRemainingGroupShards(group, priority + 10);
-      queueGroupFullHistory(group, priority);
-    });
-  }
-
-  function prefetchGroupOnIntent(group) {
-    fetchGroupShard(group, 0, 0);
-  }
-
-  // -----------------------------------------------------------------------
-  // Global filter bar wiring.
-  //
-  // Chips live in `.global-filter-bar`. Click a non-"all" chip to toggle
-  // that engine/format in/out of the active set; click "all" to clear the
-  // filter for that dimension. After every change we:
-  //   1. Re-paint the chips.
-  //   2. Walk every chart on the page and re-apply the filter (skipping
-  //      series the user has explicitly overridden on that card).
-  //   3. Sync the URL with `history.replaceState` so a refresh / share
-  //      preserves the view.
-  // -----------------------------------------------------------------------
-  // Apply the layered filter on a single card. Layer order matches the
-  // resolution rule documented at the top of the file:
-  //   1. Per-card legend overrides (`canvas.__bench_overrides`) win.
-  //   2. Per-group filter (`section.__bench_group_filter`) hides next.
-  //   3. Global filter hides last.
-  //   4. Otherwise show.
-  // Used by every code path that mutates filter state (global chip clicks,
-  // per-group chip clicks, post-construction seeding).
-  function applyFiltersToChart(card) {
-    var canvas = card.querySelector("canvas");
-    var chart = canvas && canvas.__bench_chart;
-    if (!chart) return;
-    var overrides = canvas.__bench_overrides || {};
-    var section = card.closest(".group-details");
-    var groupFilter = section && section.__bench_group_filter;
-    var datasets = chart.data.datasets || [];
-    for (var i = 0; i < datasets.length; i++) {
-      var ds = datasets[i];
-      if (overrides[ds.label]) continue;
-      var hidden = false;
-      if (!seriesPassesGroupFilter(groupFilter, ds.label)) {
-        hidden = true;
-      } else if (!seriesPassesFilter(ds.benchMeta)) {
-        hidden = true;
-      }
-      // Use the dataset.hidden field directly so the legend stays in sync;
-      // setDatasetVisibility writes into a separate visibility map.
-      ds.hidden = hidden;
-    }
-    chart.update("none");
-  }
-
-  function applyGlobalFilterEverywhere() {
-    document.querySelectorAll(".chart-card[data-chart-index]").forEach(function (card) {
-      applyFiltersToChart(card);
-    });
-  }
-
-  function syncFilterChipsUi() {
-    var bar = document.querySelector('[data-role="global-filter-bar"]');
-    if (!bar) return;
-    bar.querySelectorAll(".filter-chip").forEach(function (chip) {
-      var dim = chip.getAttribute("data-filter");
-      var value = chip.getAttribute("data-value");
-      var key = dim === "engine" ? "engines" : "formats";
-      var list = globalFilter[key];
-      var active;
-      if (value === "*") {
-        // The "all" chip is a one-shot reset, never a "current state"
-        // indicator — leave it inactive. Pressing it forces every other
-        // chip in the row back to active.
-        active = false;
-      } else {
-        active = list.indexOf(value) !== -1;
-      }
-      chip.classList.toggle("filter-chip--active", active);
-      chip.setAttribute("aria-pressed", active ? "true" : "false");
-    });
-    syncFilterBadge();
-  }
-
-  // Show a badge on the trigger that counts how many chips are *off*
-  // (i.e. how many things the global filter is hiding). Hidden when the
-  // filter is fully open, so it's noise-free in the resting state.
-  function syncFilterBadge() {
-    var trigger = document.querySelector('[data-role="filter-trigger"]');
-    if (!trigger) return;
-    var hidden =
-      Math.max(0, filterUniverse.engines.length - globalFilter.engines.length) +
-      Math.max(0, filterUniverse.formats.length - globalFilter.formats.length);
-    var badge = trigger.querySelector('[data-role="filter-badge"]');
-    if (hidden === 0) {
-      if (badge) badge.remove();
-      return;
-    }
-    if (!badge) {
-      badge = document.createElement("span");
-      badge.className = "filter-badge";
-      badge.setAttribute("data-role", "filter-badge");
-      trigger.appendChild(badge);
-    }
-    badge.textContent = String(hidden);
-  }
-
-  function syncFilterUrl() {
-    if (!window.history || !window.history.replaceState) return;
-    var url = new URL(window.location.href);
-    // URL stays as an allowlist (`?engine=duckdb` = "show only duckdb"). We
-    // emit the param only when the active set is a strict subset of the
-    // universe; an all-active row leaves the URL clean.
-    syncDimensionUrl(url, "engine", "engines");
-    syncDimensionUrl(url, "format", "formats");
-    window.history.replaceState(null, "", url.toString());
-  }
-
-  function syncDimensionUrl(url, paramName, key) {
-    if (dimensionIsFiltered(key)) {
-      url.searchParams.set(paramName, globalFilter[key].join(","));
-    } else {
-      url.searchParams.delete(paramName);
-    }
-  }
-
-  // Toggle one chip independently. The "all" chip resets the dimension to
-  // every-chip-active; specific chips just flip their own active state.
-  function toggleFilterValue(dim, value) {
-    var key = dim === "engine" ? "engines" : "formats";
-    if (value === "*") {
-      globalFilter[key] = filterUniverse[key].slice();
-      return;
-    }
-    var list = globalFilter[key];
-    var idx = list.indexOf(value);
-    if (idx === -1) {
-      list.push(value);
-    } else {
-      list.splice(idx, 1);
-    }
-  }
-
-  // Toggle the dropdown panel open/closed. Click outside or press Escape
-  // to close. The panel is anchored under the trigger button via CSS.
-  function bindFilterDropdown() {
-    var bar = document.querySelector('[data-role="global-filter-bar"]');
-    if (!bar) return;
-    var trigger = bar.querySelector('[data-role="filter-trigger"]');
-    var panel = bar.querySelector('[data-role="filter-panel"]');
-    if (!trigger || !panel) return;
-
-    function setOpen(open) {
-      if (open) {
-        panel.removeAttribute("hidden");
-      } else {
-        panel.setAttribute("hidden", "");
-      }
-      trigger.setAttribute("aria-expanded", open ? "true" : "false");
-      bar.classList.toggle("filter-dropdown--open", open);
-    }
-    trigger.addEventListener("click", function (e) {
-      e.stopPropagation();
-      var isOpen = !panel.hasAttribute("hidden");
-      setOpen(!isOpen);
-    });
-    document.addEventListener("click", function (e) {
-      if (!bar.contains(e.target)) setOpen(false);
-    });
-    document.addEventListener("keydown", function (e) {
-      if (e.key === "Escape") setOpen(false);
-    });
-  }
-
-  function initGlobalFilterBar() {
-    var bar = document.querySelector('[data-role="global-filter-bar"]');
-    if (!bar) return;
-    bar.addEventListener("click", function (e) {
-      var chip = e.target.closest(".filter-chip");
-      if (!chip || !bar.contains(chip)) return;
-      var dim = chip.getAttribute("data-filter");
-      var value = chip.getAttribute("data-value");
-      if (!dim || !value) return;
-      toggleFilterValue(dim, value);
-      syncFilterChipsUi();
-      applyGlobalFilterEverywhere();
-      syncFilterUrl();
-    });
-    bindFilterDropdown();
-    syncFilterChipsUi();
-  }
-
-  // -----------------------------------------------------------------------
-  // Per-group toolbar wiring.
-  //
-  // Each `.group-details` section carries a `[data-role="group-toolbar"]`
-  // with Y-axis buttons and a centered filter dropdown. State lives on the
-  // section node:
-  //   section.__bench_group_filter = { hiddenSeries: [<dataset.label>, ...] }
-  //   section.__bench_group_y      = "linear" | "log" | null
-  //   section.__bench_known_series = { <label>: { engine, format, ... } }
-  //
-  // Empty `hiddenSeries` and `null` Y mean "no group override; defer to the
-  // next layer". Engine and format chips in the dropdown are macros: a click
-  // computes every known series whose `engine`/`format` matches and bulk-
-  // toggles their membership in `hiddenSeries`. The series chips are
-  // populated lazily via `noteSeriesFromCard` as charts in the group hydrate.
-  // -----------------------------------------------------------------------
-  function ensureGroupFilter(section) {
-    if (!section.__bench_group_filter) {
-      section.__bench_group_filter = { hiddenSeries: [] };
-    } else if (!section.__bench_group_filter.hiddenSeries) {
-      section.__bench_group_filter.hiddenSeries = [];
-    }
-    return section.__bench_group_filter;
-  }
-
-  function ensureKnownSeries(section) {
-    if (!section.__bench_known_series) {
-      section.__bench_known_series = {};
-    }
-    return section.__bench_known_series;
-  }
-
-  // Pull every series label from the card's payload into the section's
-  // running set. Returns true when at least one new label was added so the
-  // caller knows whether to re-render the chip row.
-  function harvestSeriesFromCanvas(section, canvas) {
-    var payload = canvas && canvas.__bench_payload;
-    var meta = payload && payload.series_meta;
-    if (!meta) return false;
-    var known = ensureKnownSeries(section);
-    var added = false;
-    Object.keys(meta).forEach(function (label) {
-      if (!known[label]) {
-        known[label] = meta[label] || {};
-        added = true;
-      }
-    });
-    return added;
-  }
-
-  // Render one button per known series into the dropdown's series row.
-  // Wipes and rebuilds — the row is small (typically <10 chips) so this is
-  // cheap and avoids tracking per-label DOM nodes. Visibility state is then
-  // resynced via `syncGroupChipsUi`.
-  function renderGroupSeriesChips(section) {
-    var container = section.querySelector('[data-role="group-series-chips"]');
-    if (!container) return;
-    var known = ensureKnownSeries(section);
-    var labels = Object.keys(known).sort();
-    while (container.firstChild) container.removeChild(container.firstChild);
-    labels.forEach(function (label) {
-      var btn = document.createElement("button");
-      btn.type = "button";
-      btn.className = "filter-chip";
-      btn.setAttribute("data-group-filter", "series");
-      btn.setAttribute("data-value", label);
-      btn.textContent = label;
-      container.appendChild(btn);
-    });
-  }
-
-  // Called whenever a card's payload becomes available (constructChart,
-  // replaceChartPayload). Folds new series labels into the section's
-  // running set, refreshes the dropdown chip row when the set grew, and
-  // re-syncs all chip + badge visuals against the current filter state.
-  function noteSeriesFromCard(card) {
-    var section = card.closest && card.closest(".group-details");
-    if (!section) return;
-    var canvas = card.querySelector("canvas");
-    if (!canvas) return;
-    if (harvestSeriesFromCanvas(section, canvas)) {
-      renderGroupSeriesChips(section);
-    }
-    syncGroupChipsUi(section);
-    syncGroupFilterBadge(section);
-  }
-
-  // Toggle a single series label in/out of the hidden set.
-  function toggleGroupSeriesValue(section, label) {
-    var filter = ensureGroupFilter(section);
-    var idx = filter.hiddenSeries.indexOf(label);
-    if (idx === -1) filter.hiddenSeries.push(label);
-    else filter.hiddenSeries.splice(idx, 1);
-  }
-
-  // Apply an engine/format macro click. Find every known series whose meta
-  // matches. If every match is currently visible, hide them all; otherwise
-  // (any match already hidden) show them all. The result is that the macro
-  // chip toggles between "all matching visible" and "all matching hidden",
-  // which mirrors the chip's own active-state semantics.
-  function applyMacroToHiddenSeries(section, dim, value) {
-    var filter = ensureGroupFilter(section);
-    var known = ensureKnownSeries(section);
-    var matching = [];
-    Object.keys(known).forEach(function (label) {
-      if (known[label] && known[label][dim] === value) matching.push(label);
-    });
-    if (!matching.length) return;
-    var allVisible = matching.every(function (l) {
-      return filter.hiddenSeries.indexOf(l) === -1;
-    });
-    if (allVisible) {
-      matching.forEach(function (l) {
-        if (filter.hiddenSeries.indexOf(l) === -1) filter.hiddenSeries.push(l);
-      });
-    } else {
-      filter.hiddenSeries = filter.hiddenSeries.filter(function (l) {
-        return matching.indexOf(l) === -1;
-      });
-    }
-  }
-
-  function syncGroupChipsUi(section) {
-    var filter = ensureGroupFilter(section);
-    var known = ensureKnownSeries(section);
-    section.querySelectorAll(
-      '[data-role="group-toolbar"] .filter-chip[data-group-filter]',
-    ).forEach(function (chip) {
-      var dim = chip.getAttribute("data-group-filter");
-      var value = chip.getAttribute("data-value");
-      var active;
-      if (value === "*") {
-        // The "all" chip is a one-shot reset, never a "current state"
-        // indicator — leave it inactive in every row.
-        active = false;
-      } else if (dim === "series") {
-        active = filter.hiddenSeries.indexOf(value) === -1;
-      } else if (dim === "engine" || dim === "format") {
-        // Macro chip is active iff at least one known series matches this
-        // dim AND every match is currently visible. When no series in the
-        // group has this engine/format the chip is inert — show it inactive
-        // so the dropdown doesn't falsely advertise irrelevant filters.
-        var matching = Object.keys(known).filter(function (l) {
-          return known[l] && known[l][dim] === value;
-        });
-        if (matching.length === 0) {
-          active = false;
-        } else {
-          active = matching.every(function (l) {
-            return filter.hiddenSeries.indexOf(l) === -1;
-          });
-        }
-      } else {
-        active = false;
-      }
-      chip.classList.toggle("filter-chip--active", active);
-      chip.setAttribute("aria-pressed", active ? "true" : "false");
-    });
-  }
-
-  // Show a count of hidden series on the trigger button when at least one
-  // is hidden; remove the badge cleanly when the filter is empty so the
-  // resting state stays noise-free. Mirrors `syncFilterBadge` for the
-  // global filter.
-  function syncGroupFilterBadge(section) {
-    var trigger = section.querySelector('[data-role="group-filter-trigger"]');
-    if (!trigger) return;
-    var filter = ensureGroupFilter(section);
-    var hidden = filter.hiddenSeries.length;
-    var badge = trigger.querySelector('[data-role="group-filter-badge"]');
-    if (hidden === 0) {
-      if (badge) badge.remove();
-      return;
-    }
-    if (!badge) {
-      badge = document.createElement("span");
-      badge.className = "filter-badge";
-      badge.setAttribute("data-role", "group-filter-badge");
-      trigger.appendChild(badge);
-    }
-    badge.textContent = String(hidden);
-  }
-
-  // Highlight whichever group-Y button matches the current state. `null`
-  // (the resting default and the post-Reset state) is treated as "linear"
-  // for the visual — matches each chart's own default — even though the
-  // resolution rule still distinguishes "no override" from an explicit
-  // user click for `applyGroupYTo`'s revert-to-linear semantics.
-  function syncGroupYUi(section) {
-    var y = section.__bench_group_y;
-    var visual = y === "log" ? "log" : "linear";
-    section.querySelectorAll(
-      '[data-role="group-toolbar"] .toolbar-btn[data-group-y]',
-    ).forEach(function (b) {
-      var match = b.getAttribute("data-group-y") === visual;
-      b.classList.toggle("toolbar-btn--active", match);
-    });
-  }
-
-  // Re-evaluate every chart-card in the section under the unified filter
-  // resolution. Per-group filter changes cascade through `applyFiltersToChart`
-  // because that function reads the section's filter on every call.
-  function applyGroupFilterTo(section) {
-    section.querySelectorAll(".chart-card[data-chart-index]").forEach(function (card) {
-      applyFiltersToChart(card);
-    });
-  }
-
-  // Broadcast the per-group Y-axis setting. Skips cards with
-  // `__bench_y_user_set` so the user's per-chart click stays sticky. When
-  // the section's group Y is null (e.g. after Reset), revert non-overridden
-  // cards to the default linear scale.
-  function applyGroupYTo(section) {
-    var y = section.__bench_group_y;
-    var target = (y === "linear" || y === "log") ? y : "linear";
-    section.querySelectorAll(".chart-card[data-chart-index]").forEach(function (card) {
-      var canvas = card.querySelector("canvas");
-      if (!canvas || !canvas.__bench_chart) return;
-      if (canvas.__bench_y_user_set) return;
-      applyY(card, target, false);
-    });
-  }
-
-  // Open/close behaviour for the per-group filter dropdown. Mirrors
-  // `bindFilterDropdown` for the global filter — click outside or press
-  // Escape to close. The trigger calls `e.stopPropagation()` so the
-  // document-level "click outside" listener doesn't immediately reclose
-  // the panel on the same click that opened it.
-  function bindGroupFilterDropdown(section) {
-    var dropdown = section.querySelector('[data-role="group-filter-dropdown"]');
-    if (!dropdown || dropdown.__bench_bound) return;
-    dropdown.__bench_bound = true;
-    var trigger = dropdown.querySelector('[data-role="group-filter-trigger"]');
-    var panel = dropdown.querySelector('[data-role="group-filter-panel"]');
-    if (!trigger || !panel) return;
-    function setOpen(open) {
-      if (open) {
-        panel.removeAttribute("hidden");
-      } else {
-        panel.setAttribute("hidden", "");
-      }
-      trigger.setAttribute("aria-expanded", open ? "true" : "false");
-      dropdown.classList.toggle("group-filter-dropdown--open", open);
-    }
-    trigger.addEventListener("click", function (e) {
-      e.stopPropagation();
-      var isOpen = !panel.hasAttribute("hidden");
-      setOpen(!isOpen);
-    });
-    document.addEventListener("click", function (e) {
-      if (!dropdown.contains(e.target)) setOpen(false);
-    });
-    document.addEventListener("keydown", function (e) {
-      if (e.key === "Escape") setOpen(false);
-    });
-  }
-
-  function bindGroupToolbar(section) {
-    var toolbar = section.querySelector('[data-role="group-toolbar"]');
-    if (!toolbar || toolbar.__bench_bound) return;
-    toolbar.__bench_bound = true;
-    bindGroupFilterDropdown(section);
-    toolbar.addEventListener("click", function (e) {
-      var target = e.target;
-      var resetBtn = target.closest && target.closest('[data-role="group-toolbar-reset"]');
-      if (resetBtn && toolbar.contains(resetBtn)) {
-        section.__bench_group_filter = { hiddenSeries: [] };
-        section.__bench_group_y = null;
-        syncGroupChipsUi(section);
-        syncGroupYUi(section);
-        syncGroupFilterBadge(section);
-        applyGroupYTo(section);
-        applyGroupFilterTo(section);
-        return;
-      }
-      var yBtn = target.closest && target.closest('.toolbar-btn[data-group-y]');
-      if (yBtn && toolbar.contains(yBtn)) {
-        section.__bench_group_y = yBtn.getAttribute("data-group-y");
-        syncGroupYUi(section);
-        applyGroupYTo(section);
-        return;
-      }
-      var chip = target.closest && target.closest('.filter-chip[data-group-filter]');
-      if (chip && toolbar.contains(chip)) {
-        var dim = chip.getAttribute("data-group-filter");
-        var value = chip.getAttribute("data-value");
-        if (!dim || !value) return;
-        if (value === "*") {
-          ensureGroupFilter(section).hiddenSeries = [];
-        } else if (dim === "series") {
-          toggleGroupSeriesValue(section, value);
-        } else {
-          applyMacroToHiddenSeries(section, dim, value);
-        }
-        syncGroupChipsUi(section);
-        syncGroupFilterBadge(section);
-        applyGroupFilterTo(section);
-      }
-    });
-  }
-
-  function initGroupToolbars() {
-    document.querySelectorAll(".group-details").forEach(function (section) {
-      bindGroupToolbar(section);
-      syncGroupChipsUi(section);
-      syncGroupYUi(section);
-      syncGroupFilterBadge(section);
-    });
-  }
-
-  // -----------------------------------------------------------------------
-  // Header controls
-  // -----------------------------------------------------------------------
-  function effectiveTheme() {
-    var forced = document.documentElement.getAttribute("data-theme");
-    if (forced === "light" || forced === "dark") return forced;
-    if (window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches) {
-      return "dark";
-    }
-    return "light";
-  }
-
-  function setTheme(theme) {
-    if (theme === "light" || theme === "dark") {
-      document.documentElement.setAttribute("data-theme", theme);
-      try { localStorage.setItem("bench-theme", theme); } catch (e) {}
-    }
-    updateThemeButtons();
-  }
-
-  function updateThemeButtons() {
-    var next = effectiveTheme() === "light" ? "Dark" : "Light";
-    var nextTheme = next.toLowerCase();
-    document.querySelectorAll('[data-role="theme-toggle"]').forEach(function (btn) {
-      var label = btn.querySelector(".theme-toggle-label");
-      if (label) label.textContent = next;
-      btn.setAttribute("data-next-theme", nextTheme);
-      btn.setAttribute("aria-label", "Switch to " + nextTheme + " mode");
-    });
-  }
-
-  function setAllGroups(open) {
-    document.querySelectorAll("details.group-disclosure").forEach(function (disclosure) {
-      disclosure.open = open;
-      if (open) hydrateOpenGroup(disclosure);
-    });
-  }
-
-  function initHeaderControls() {
-    updateThemeButtons();
-    document.querySelectorAll('[data-role="theme-toggle"]').forEach(function (btn) {
-      btn.addEventListener("click", function () {
-        setTheme(effectiveTheme() === "light" ? "dark" : "light");
-      });
-    });
-    document.querySelectorAll('[data-action="expand-all"]').forEach(function (btn) {
-      btn.addEventListener("click", function () { setAllGroups(true); });
-    });
-    document.querySelectorAll('[data-action="collapse-all"]').forEach(function (btn) {
-      btn.addEventListener("click", function () { setAllGroups(false); });
-    });
-    bindMobileNav();
-  }
-
-  // Hamburger toggle for the mobile-only nav panel. The panel itself is
-  // `.nav-controls`; CSS hides it at < 769px until `.nav-controls--open`
-  // is planted on it. Mirrors the open/close-on-outside-click pattern used
-  // by the global filter dropdown.
-  function bindMobileNav() {
-    var toggle = document.querySelector('[data-role="nav-mobile-toggle"]');
-    var nav = document.querySelector('[data-role="nav-controls"]');
-    if (!toggle || !nav) return;
-    function setOpen(open) {
-      nav.classList.toggle("nav-controls--open", open);
-      toggle.setAttribute("aria-expanded", open ? "true" : "false");
-    }
-    toggle.addEventListener("click", function (e) {
-      e.stopPropagation();
-      var isOpen = nav.classList.contains("nav-controls--open");
-      setOpen(!isOpen);
-    });
-    document.addEventListener("click", function (e) {
-      if (!nav.contains(e.target) && !toggle.contains(e.target)) {
-        setOpen(false);
-      }
-    });
-    document.addEventListener("keydown", function (e) {
-      if (e.key === "Escape") setOpen(false);
-    });
-  }
-
-  // -----------------------------------------------------------------------
-  // Page wiring
-  // -----------------------------------------------------------------------
-  function initOpenCharts() {
-    // Charts that arrive with inline JSON (`<script id="chart-data-N">`):
-    // construct them via IntersectionObserver as before so a long open page
-    // doesn't pay for offscreen Chart.js cost up front.
-    var cards = document.querySelectorAll(".chart-card[data-chart-index]");
-    if (!cards.length) return;
-
-    var construct = function (card) {
-      // Skip cards whose group disclosure is closed — they'll be picked up
-      // on toggle. Summaries live outside the disclosure so they remain
-      // visible while the chart grid is collapsed.
-      var group = card.closest(".group-details");
-      var details = group ? group.querySelector("details.group-disclosure") : null;
-      if (details && !details.open) return;
-      if (constructChart(card)) bindToolbar(card);
-    };
-
-    if (typeof IntersectionObserver === "undefined") {
-      cards.forEach(construct);
-    } else {
-      var io = new IntersectionObserver(function (entries) {
-        entries.forEach(function (entry) {
-          if (entry.isIntersecting) {
-            construct(entry.target);
-            io.unobserve(entry.target);
-          }
-        });
-      }, { rootMargin: "150px 0px" });
-      cards.forEach(function (card) { io.observe(card); });
-    }
-  }
-
-  function initDetailsToggle() {
-    var groups = document.querySelectorAll("details.group-disclosure");
-    groups.forEach(function (d) {
-      d.addEventListener("toggle", function () {
-        if (!d.open) return;
-        hydrateOpenGroup(d);
-      });
-      if (d.open) hydrateOpenGroup(d);
-    });
-  }
-
-  function initGroupIntentPrefetch() {
-    document.querySelectorAll(".group-details").forEach(function (group) {
-      if (group.__bench_intent_prefetch_bound) return;
-      group.__bench_intent_prefetch_bound = true;
-      var summary = group.querySelector(".group-summary");
-      var target = summary || group;
-      target.addEventListener("pointerenter", function () {
-        prefetchGroupOnIntent(group);
-      });
-      target.addEventListener("focusin", function () {
-        prefetchGroupOnIntent(group);
-      });
-    });
-  }
-
-  function init() {
-    initHeaderControls();
-    initGlobalFilterBar();
-    initGroupToolbars();
-    initDetailsToggle();
-    initGroupIntentPrefetch();
-    initOpenCharts();
-  }
-
-  if (document.readyState === "loading") {
-    document.addEventListener("DOMContentLoaded", init);
-  } else {
-    init();
-  }
-})();
diff --git a/benchmarks-website/server/static/chart.umd.js b/benchmarks-website/server/static/chart.umd.js
deleted file mode 100644
index 8e43e996a64..00000000000
--- a/benchmarks-website/server/static/chart.umd.js
+++ /dev/null
@@ -1,14 +0,0 @@
-/*!
- * Chart.js v4.4.4
- * https://www.chartjs.org
- * (c) 2024 Chart.js Contributors
- * Released under the MIT License
- */
-!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).Chart=e()}(this,(function(){"use strict";var t=Object.freeze({__proto__:null,get Colors(){return Go},get Decimation(){return Qo},get Filler(){return ma},get Legend(){return ya},get SubTitle(){return ka},get Title(){return Ma},get Tooltip(){return Ba}});function e(){}const i=(()=>{let t=0;return()=>t++})();function s(t){return null==t}function n(t){if(Array.isArray&&Array.isArray(t))return!0;const e=Object.prototype.toString.call(t);return"[object"===e.slice(0,7)&&"Array]"===e.slice(-6)}function o(t){return null!==t&&"[object Object]"===Object.prototype.toString.call(t)}function a(t){return("number"==typeof t||t instanceof Number)&&isFinite(+t)}function r(t,e){return a(t)?t:e}function l(t,e){return void 0===t?e:t}const h=(t,e)=>"string"==typeof t&&t.endsWith("%")?parseFloat(t)/100:+t/e,c=(t,e)=>"string"==typeof t&&t.endsWith("%")?parseFloat(t)/100*e:+t;function d(t,e,i){if(t&&"function"==typeof t.call)return t.apply(i,e)}function u(t,e,i,s){let a,r,l;if(n(t))if(r=t.length,s)for(a=r-1;a>=0;a--)e.call(i,t[a],a);else for(a=0;a<r;a++)e.call(i,t[a],a);else if(o(t))for(l=Object.keys(t),r=l.length,a=0;a<r;a++)e.call(i,t[l[a]],l[a])}function f(t,e){let i,s,n,o;if(!t||!e||t.length!==e.length)return!1;for(i=0,s=t.length;i<s;++i)if(n=t[i],o=e[i],n.datasetIndex!==o.datasetIndex||n.index!==o.index)return!1;return!0}function g(t){if(n(t))return t.map(g);if(o(t)){const e=Object.create(null),i=Object.keys(t),s=i.length;let n=0;for(;n<s;++n)e[i[n]]=g(t[i[n]]);return e}return t}function p(t){return-1===["__proto__","prototype","constructor"].indexOf(t)}function m(t,e,i,s){if(!p(t))return;const n=e[t],a=i[t];o(n)&&o(a)?x(n,a,s):e[t]=g(a)}function x(t,e,i){const s=n(e)?e:[e],a=s.length;if(!o(t))return t;const r=(i=i||{}).merger||m;let l;for(let e=0;e<a;++e){if(l=s[e],!o(l))continue;const n=Object.keys(l);for(let e=0,s=n.length;e<s;++e)r(n[e],t,l,i)}return t}function b(t,e){return x(t,e,{merger:_})}function _(t,e,i){if(!p(t))return;const s=e[t],n=i[t];o(s)&&o(n)?b(s,n):Object.prototype.hasOwnProperty.call(e,t)||(e[t]=g(n))}const y={"":t=>t,x:t=>t.x,y:t=>t.y};function v(t){const e=t.split("."),i=[];let s="";for(const t of e)s+=t,s.endsWith("\\")?s=s.slice(0,-1)+".":(i.push(s),s="");return i}function M(t,e){const i=y[e]||(y[e]=function(t){const e=v(t);return t=>{for(const i of e){if(""===i)break;t=t&&t[i]}return t}}(e));return i(t)}function w(t){return t.charAt(0).toUpperCase()+t.slice(1)}const k=t=>void 0!==t,S=t=>"function"==typeof t,P=(t,e)=>{if(t.size!==e.size)return!1;for(const i of t)if(!e.has(i))return!1;return!0};function D(t){return"mouseup"===t.type||"click"===t.type||"contextmenu"===t.type}const C=Math.PI,O=2*C,A=O+C,T=Number.POSITIVE_INFINITY,L=C/180,E=C/2,R=C/4,I=2*C/3,z=Math.log10,F=Math.sign;function V(t,e,i){return Math.abs(t-e)<i}function B(t){const e=Math.round(t);t=V(t,e,t/1e3)?e:t;const i=Math.pow(10,Math.floor(z(t))),s=t/i;return(s<=1?1:s<=2?2:s<=5?5:10)*i}function W(t){const e=[],i=Math.sqrt(t);let s;for(s=1;s<i;s++)t%s==0&&(e.push(s),e.push(t/s));return i===(0|i)&&e.push(i),e.sort(((t,e)=>t-e)).pop(),e}function N(t){return!isNaN(parseFloat(t))&&isFinite(t)}function H(t,e){const i=Math.round(t);return i-e<=t&&i+e>=t}function j(t,e,i){let s,n,o;for(s=0,n=t.length;s<n;s++)o=t[s][i],isNaN(o)||(e.min=Math.min(e.min,o),e.max=Math.max(e.max,o))}function $(t){return t*(C/180)}function Y(t){return t*(180/C)}function U(t){if(!a(t))return;let e=1,i=0;for(;Math.round(t*e)/e!==t;)e*=10,i++;return i}function X(t,e){const i=e.x-t.x,s=e.y-t.y,n=Math.sqrt(i*i+s*s);let o=Math.atan2(s,i);return o<-.5*C&&(o+=O),{angle:o,distance:n}}function q(t,e){return Math.sqrt(Math.pow(e.x-t.x,2)+Math.pow(e.y-t.y,2))}function K(t,e){return(t-e+A)%O-C}function G(t){return(t%O+O)%O}function Z(t,e,i,s){const n=G(t),o=G(e),a=G(i),r=G(o-n),l=G(a-n),h=G(n-o),c=G(n-a);return n===o||n===a||s&&o===a||r>l&&h<c}function J(t,e,i){return Math.max(e,Math.min(i,t))}function Q(t){return J(t,-32768,32767)}function tt(t,e,i,s=1e-6){return t>=Math.min(e,i)-s&&t<=Math.max(e,i)+s}function et(t,e,i){i=i||(i=>t[i]<e);let s,n=t.length-1,o=0;for(;n-o>1;)s=o+n>>1,i(s)?o=s:n=s;return{lo:o,hi:n}}const it=(t,e,i,s)=>et(t,i,s?s=>{const n=t[s][e];return n<i||n===i&&t[s+1][e]===i}:s=>t[s][e]<i),st=(t,e,i)=>et(t,i,(s=>t[s][e]>=i));function nt(t,e,i){let s=0,n=t.length;for(;s<n&&t[s]<e;)s++;for(;n>s&&t[n-1]>i;)n--;return s>0||n<t.length?t.slice(s,n):t}const ot=["push","pop","shift","splice","unshift"];function at(t,e){t._chartjs?t._chartjs.listeners.push(e):(Object.defineProperty(t,"_chartjs",{configurable:!0,enumerable:!1,value:{listeners:[e]}}),ot.forEach((e=>{const i="_onData"+w(e),s=t[e];Object.defineProperty(t,e,{configurable:!0,enumerable:!1,value(...e){const n=s.apply(this,e);return t._chartjs.listeners.forEach((t=>{"function"==typeof t[i]&&t[i](...e)})),n}})})))}function rt(t,e){const i=t._chartjs;if(!i)return;const s=i.listeners,n=s.indexOf(e);-1!==n&&s.splice(n,1),s.length>0||(ot.forEach((e=>{delete t[e]})),delete t._chartjs)}function lt(t){const e=new Set(t);return e.size===t.length?t:Array.from(e)}const ht="undefined"==typeof window?function(t){return t()}:window.requestAnimationFrame;function ct(t,e){let i=[],s=!1;return function(...n){i=n,s||(s=!0,ht.call(window,(()=>{s=!1,t.apply(e,i)})))}}function dt(t,e){let i;return function(...s){return e?(clearTimeout(i),i=setTimeout(t,e,s)):t.apply(this,s),e}}const ut=t=>"start"===t?"left":"end"===t?"right":"center",ft=(t,e,i)=>"start"===t?e:"end"===t?i:(e+i)/2,gt=(t,e,i,s)=>t===(s?"left":"right")?i:"center"===t?(e+i)/2:e;function pt(t,e,i){const s=e.length;let n=0,o=s;if(t._sorted){const{iScale:a,_parsed:r}=t,l=a.axis,{min:h,max:c,minDefined:d,maxDefined:u}=a.getUserBounds();d&&(n=J(Math.min(it(r,l,h).lo,i?s:it(e,l,a.getPixelForValue(h)).lo),0,s-1)),o=u?J(Math.max(it(r,a.axis,c,!0).hi+1,i?0:it(e,l,a.getPixelForValue(c),!0).hi+1),n,s)-n:s-n}return{start:n,count:o}}function mt(t){const{xScale:e,yScale:i,_scaleRanges:s}=t,n={xmin:e.min,xmax:e.max,ymin:i.min,ymax:i.max};if(!s)return t._scaleRanges=n,!0;const o=s.xmin!==e.min||s.xmax!==e.max||s.ymin!==i.min||s.ymax!==i.max;return Object.assign(s,n),o}class xt{constructor(){this._request=null,this._charts=new Map,this._running=!1,this._lastDate=void 0}_notify(t,e,i,s){const n=e.listeners[s],o=e.duration;n.forEach((s=>s({chart:t,initial:e.initial,numSteps:o,currentStep:Math.min(i-e.start,o)})))}_refresh(){this._request||(this._running=!0,this._request=ht.call(window,(()=>{this._update(),this._request=null,this._running&&this._refresh()})))}_update(t=Date.now()){let e=0;this._charts.forEach(((i,s)=>{if(!i.running||!i.items.length)return;const n=i.items;let o,a=n.length-1,r=!1;for(;a>=0;--a)o=n[a],o._active?(o._total>i.duration&&(i.duration=o._total),o.tick(t),r=!0):(n[a]=n[n.length-1],n.pop());r&&(s.draw(),this._notify(s,i,t,"progress")),n.length||(i.running=!1,this._notify(s,i,t,"complete"),i.initial=!1),e+=n.length})),this._lastDate=t,0===e&&(this._running=!1)}_getAnims(t){const e=this._charts;let i=e.get(t);return i||(i={running:!1,initial:!0,items:[],listeners:{complete:[],progress:[]}},e.set(t,i)),i}listen(t,e,i){this._getAnims(t).listeners[e].push(i)}add(t,e){e&&e.length&&this._getAnims(t).items.push(...e)}has(t){return this._getAnims(t).items.length>0}start(t){const e=this._charts.get(t);e&&(e.running=!0,e.start=Date.now(),e.duration=e.items.reduce(((t,e)=>Math.max(t,e._duration)),0),this._refresh())}running(t){if(!this._running)return!1;const e=this._charts.get(t);return!!(e&&e.running&&e.items.length)}stop(t){const e=this._charts.get(t);if(!e||!e.items.length)return;const i=e.items;let s=i.length-1;for(;s>=0;--s)i[s].cancel();e.items=[],this._notify(t,e,Date.now(),"complete")}remove(t){return this._charts.delete(t)}}var bt=new xt;
-/*!
- * @kurkle/color v0.3.2
- * https://github.com/kurkle/color#readme
- * (c) 2023 Jukka Kurkela
- * Released under the MIT License
- */function _t(t){return t+.5|0}const yt=(t,e,i)=>Math.max(Math.min(t,i),e);function vt(t){return yt(_t(2.55*t),0,255)}function Mt(t){return yt(_t(255*t),0,255)}function wt(t){return yt(_t(t/2.55)/100,0,1)}function kt(t){return yt(_t(100*t),0,100)}const St={0:0,1:1,2:2,3:3,4:4,5:5,6:6,7:7,8:8,9:9,A:10,B:11,C:12,D:13,E:14,F:15,a:10,b:11,c:12,d:13,e:14,f:15},Pt=[..."0123456789ABCDEF"],Dt=t=>Pt[15&t],Ct=t=>Pt[(240&t)>>4]+Pt[15&t],Ot=t=>(240&t)>>4==(15&t);function At(t){var e=(t=>Ot(t.r)&&Ot(t.g)&&Ot(t.b)&&Ot(t.a))(t)?Dt:Ct;return t?"#"+e(t.r)+e(t.g)+e(t.b)+((t,e)=>t<255?e(t):"")(t.a,e):void 0}const Tt=/^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/;function Lt(t,e,i){const s=e*Math.min(i,1-i),n=(e,n=(e+t/30)%12)=>i-s*Math.max(Math.min(n-3,9-n,1),-1);return[n(0),n(8),n(4)]}function Et(t,e,i){const s=(s,n=(s+t/60)%6)=>i-i*e*Math.max(Math.min(n,4-n,1),0);return[s(5),s(3),s(1)]}function Rt(t,e,i){const s=Lt(t,1,.5);let n;for(e+i>1&&(n=1/(e+i),e*=n,i*=n),n=0;n<3;n++)s[n]*=1-e-i,s[n]+=e;return s}function It(t){const e=t.r/255,i=t.g/255,s=t.b/255,n=Math.max(e,i,s),o=Math.min(e,i,s),a=(n+o)/2;let r,l,h;return n!==o&&(h=n-o,l=a>.5?h/(2-n-o):h/(n+o),r=function(t,e,i,s,n){return t===n?(e-i)/s+(e<i?6:0):e===n?(i-t)/s+2:(t-e)/s+4}(e,i,s,h,n),r=60*r+.5),[0|r,l||0,a]}function zt(t,e,i,s){return(Array.isArray(e)?t(e[0],e[1],e[2]):t(e,i,s)).map(Mt)}function Ft(t,e,i){return zt(Lt,t,e,i)}function Vt(t){return(t%360+360)%360}function Bt(t){const e=Tt.exec(t);let i,s=255;if(!e)return;e[5]!==i&&(s=e[6]?vt(+e[5]):Mt(+e[5]));const n=Vt(+e[2]),o=+e[3]/100,a=+e[4]/100;return i="hwb"===e[1]?function(t,e,i){return zt(Rt,t,e,i)}(n,o,a):"hsv"===e[1]?function(t,e,i){return zt(Et,t,e,i)}(n,o,a):Ft(n,o,a),{r:i[0],g:i[1],b:i[2],a:s}}const Wt={x:"dark",Z:"light",Y:"re",X:"blu",W:"gr",V:"medium",U:"slate",A:"ee",T:"ol",S:"or",B:"ra",C:"lateg",D:"ights",R:"in",Q:"turquois",E:"hi",P:"ro",O:"al",N:"le",M:"de",L:"yello",F:"en",K:"ch",G:"arks",H:"ea",I:"ightg",J:"wh"},Nt={OiceXe:"f0f8ff",antiquewEte:"faebd7",aqua:"ffff",aquamarRe:"7fffd4",azuY:"f0ffff",beige:"f5f5dc",bisque:"ffe4c4",black:"0",blanKedOmond:"ffebcd",Xe:"ff",XeviTet:"8a2be2",bPwn:"a52a2a",burlywood:"deb887",caMtXe:"5f9ea0",KartYuse:"7fff00",KocTate:"d2691e",cSO:"ff7f50",cSnflowerXe:"6495ed",cSnsilk:"fff8dc",crimson:"dc143c",cyan:"ffff",xXe:"8b",xcyan:"8b8b",xgTMnPd:"b8860b",xWay:"a9a9a9",xgYF:"6400",xgYy:"a9a9a9",xkhaki:"bdb76b",xmagFta:"8b008b",xTivegYF:"556b2f",xSange:"ff8c00",xScEd:"9932cc",xYd:"8b0000",xsOmon:"e9967a",xsHgYF:"8fbc8f",xUXe:"483d8b",xUWay:"2f4f4f",xUgYy:"2f4f4f",xQe:"ced1",xviTet:"9400d3",dAppRk:"ff1493",dApskyXe:"bfff",dimWay:"696969",dimgYy:"696969",dodgerXe:"1e90ff",fiYbrick:"b22222",flSOwEte:"fffaf0",foYstWAn:"228b22",fuKsia:"ff00ff",gaRsbSo:"dcdcdc",ghostwEte:"f8f8ff",gTd:"ffd700",gTMnPd:"daa520",Way:"808080",gYF:"8000",gYFLw:"adff2f",gYy:"808080",honeyMw:"f0fff0",hotpRk:"ff69b4",RdianYd:"cd5c5c",Rdigo:"4b0082",ivSy:"fffff0",khaki:"f0e68c",lavFMr:"e6e6fa",lavFMrXsh:"fff0f5",lawngYF:"7cfc00",NmoncEffon:"fffacd",ZXe:"add8e6",ZcSO:"f08080",Zcyan:"e0ffff",ZgTMnPdLw:"fafad2",ZWay:"d3d3d3",ZgYF:"90ee90",ZgYy:"d3d3d3",ZpRk:"ffb6c1",ZsOmon:"ffa07a",ZsHgYF:"20b2aa",ZskyXe:"87cefa",ZUWay:"778899",ZUgYy:"778899",ZstAlXe:"b0c4de",ZLw:"ffffe0",lime:"ff00",limegYF:"32cd32",lRF:"faf0e6",magFta:"ff00ff",maPon:"800000",VaquamarRe:"66cdaa",VXe:"cd",VScEd:"ba55d3",VpurpN:"9370db",VsHgYF:"3cb371",VUXe:"7b68ee",VsprRggYF:"fa9a",VQe:"48d1cc",VviTetYd:"c71585",midnightXe:"191970",mRtcYam:"f5fffa",mistyPse:"ffe4e1",moccasR:"ffe4b5",navajowEte:"ffdead",navy:"80",Tdlace:"fdf5e6",Tive:"808000",TivedBb:"6b8e23",Sange:"ffa500",SangeYd:"ff4500",ScEd:"da70d6",pOegTMnPd:"eee8aa",pOegYF:"98fb98",pOeQe:"afeeee",pOeviTetYd:"db7093",papayawEp:"ffefd5",pHKpuff:"ffdab9",peru:"cd853f",pRk:"ffc0cb",plum:"dda0dd",powMrXe:"b0e0e6",purpN:"800080",YbeccapurpN:"663399",Yd:"ff0000",Psybrown:"bc8f8f",PyOXe:"4169e1",saddNbPwn:"8b4513",sOmon:"fa8072",sandybPwn:"f4a460",sHgYF:"2e8b57",sHshell:"fff5ee",siFna:"a0522d",silver:"c0c0c0",skyXe:"87ceeb",UXe:"6a5acd",UWay:"708090",UgYy:"708090",snow:"fffafa",sprRggYF:"ff7f",stAlXe:"4682b4",tan:"d2b48c",teO:"8080",tEstN:"d8bfd8",tomato:"ff6347",Qe:"40e0d0",viTet:"ee82ee",JHt:"f5deb3",wEte:"ffffff",wEtesmoke:"f5f5f5",Lw:"ffff00",LwgYF:"9acd32"};let Ht;function jt(t){Ht||(Ht=function(){const t={},e=Object.keys(Nt),i=Object.keys(Wt);let s,n,o,a,r;for(s=0;s<e.length;s++){for(a=r=e[s],n=0;n<i.length;n++)o=i[n],r=r.replace(o,Wt[o]);o=parseInt(Nt[a],16),t[r]=[o>>16&255,o>>8&255,255&o]}return t}(),Ht.transparent=[0,0,0,0]);const e=Ht[t.toLowerCase()];return e&&{r:e[0],g:e[1],b:e[2],a:4===e.length?e[3]:255}}const $t=/^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/;const Yt=t=>t<=.0031308?12.92*t:1.055*Math.pow(t,1/2.4)-.055,Ut=t=>t<=.04045?t/12.92:Math.pow((t+.055)/1.055,2.4);function Xt(t,e,i){if(t){let s=It(t);s[e]=Math.max(0,Math.min(s[e]+s[e]*i,0===e?360:1)),s=Ft(s),t.r=s[0],t.g=s[1],t.b=s[2]}}function qt(t,e){return t?Object.assign(e||{},t):t}function Kt(t){var e={r:0,g:0,b:0,a:255};return Array.isArray(t)?t.length>=3&&(e={r:t[0],g:t[1],b:t[2],a:255},t.length>3&&(e.a=Mt(t[3]))):(e=qt(t,{r:0,g:0,b:0,a:1})).a=Mt(e.a),e}function Gt(t){return"r"===t.charAt(0)?function(t){const e=$t.exec(t);let i,s,n,o=255;if(e){if(e[7]!==i){const t=+e[7];o=e[8]?vt(t):yt(255*t,0,255)}return i=+e[1],s=+e[3],n=+e[5],i=255&(e[2]?vt(i):yt(i,0,255)),s=255&(e[4]?vt(s):yt(s,0,255)),n=255&(e[6]?vt(n):yt(n,0,255)),{r:i,g:s,b:n,a:o}}}(t):Bt(t)}class Zt{constructor(t){if(t instanceof Zt)return t;const e=typeof t;let i;var s,n,o;"object"===e?i=Kt(t):"string"===e&&(o=(s=t).length,"#"===s[0]&&(4===o||5===o?n={r:255&17*St[s[1]],g:255&17*St[s[2]],b:255&17*St[s[3]],a:5===o?17*St[s[4]]:255}:7!==o&&9!==o||(n={r:St[s[1]]<<4|St[s[2]],g:St[s[3]]<<4|St[s[4]],b:St[s[5]]<<4|St[s[6]],a:9===o?St[s[7]]<<4|St[s[8]]:255})),i=n||jt(t)||Gt(t)),this._rgb=i,this._valid=!!i}get valid(){return this._valid}get rgb(){var t=qt(this._rgb);return t&&(t.a=wt(t.a)),t}set rgb(t){this._rgb=Kt(t)}rgbString(){return this._valid?(t=this._rgb)&&(t.a<255?`rgba(${t.r}, ${t.g}, ${t.b}, ${wt(t.a)})`:`rgb(${t.r}, ${t.g}, ${t.b})`):void 0;var t}hexString(){return this._valid?At(this._rgb):void 0}hslString(){return this._valid?function(t){if(!t)return;const e=It(t),i=e[0],s=kt(e[1]),n=kt(e[2]);return t.a<255?`hsla(${i}, ${s}%, ${n}%, ${wt(t.a)})`:`hsl(${i}, ${s}%, ${n}%)`}(this._rgb):void 0}mix(t,e){if(t){const i=this.rgb,s=t.rgb;let n;const o=e===n?.5:e,a=2*o-1,r=i.a-s.a,l=((a*r==-1?a:(a+r)/(1+a*r))+1)/2;n=1-l,i.r=255&l*i.r+n*s.r+.5,i.g=255&l*i.g+n*s.g+.5,i.b=255&l*i.b+n*s.b+.5,i.a=o*i.a+(1-o)*s.a,this.rgb=i}return this}interpolate(t,e){return t&&(this._rgb=function(t,e,i){const s=Ut(wt(t.r)),n=Ut(wt(t.g)),o=Ut(wt(t.b));return{r:Mt(Yt(s+i*(Ut(wt(e.r))-s))),g:Mt(Yt(n+i*(Ut(wt(e.g))-n))),b:Mt(Yt(o+i*(Ut(wt(e.b))-o))),a:t.a+i*(e.a-t.a)}}(this._rgb,t._rgb,e)),this}clone(){return new Zt(this.rgb)}alpha(t){return this._rgb.a=Mt(t),this}clearer(t){return this._rgb.a*=1-t,this}greyscale(){const t=this._rgb,e=_t(.3*t.r+.59*t.g+.11*t.b);return t.r=t.g=t.b=e,this}opaquer(t){return this._rgb.a*=1+t,this}negate(){const t=this._rgb;return t.r=255-t.r,t.g=255-t.g,t.b=255-t.b,this}lighten(t){return Xt(this._rgb,2,t),this}darken(t){return Xt(this._rgb,2,-t),this}saturate(t){return Xt(this._rgb,1,t),this}desaturate(t){return Xt(this._rgb,1,-t),this}rotate(t){return function(t,e){var i=It(t);i[0]=Vt(i[0]+e),i=Ft(i),t.r=i[0],t.g=i[1],t.b=i[2]}(this._rgb,t),this}}function Jt(t){if(t&&"object"==typeof t){const e=t.toString();return"[object CanvasPattern]"===e||"[object CanvasGradient]"===e}return!1}function Qt(t){return Jt(t)?t:new Zt(t)}function te(t){return Jt(t)?t:new Zt(t).saturate(.5).darken(.1).hexString()}const ee=["x","y","borderWidth","radius","tension"],ie=["color","borderColor","backgroundColor"];const se=new Map;function ne(t,e,i){return function(t,e){e=e||{};const i=t+JSON.stringify(e);let s=se.get(i);return s||(s=new Intl.NumberFormat(t,e),se.set(i,s)),s}(e,i).format(t)}const oe={values:t=>n(t)?t:""+t,numeric(t,e,i){if(0===t)return"0";const s=this.chart.options.locale;let n,o=t;if(i.length>1){const e=Math.max(Math.abs(i[0].value),Math.abs(i[i.length-1].value));(e<1e-4||e>1e15)&&(n="scientific"),o=function(t,e){let i=e.length>3?e[2].value-e[1].value:e[1].value-e[0].value;Math.abs(i)>=1&&t!==Math.floor(t)&&(i=t-Math.floor(t));return i}(t,i)}const a=z(Math.abs(o)),r=isNaN(a)?1:Math.max(Math.min(-1*Math.floor(a),20),0),l={notation:n,minimumFractionDigits:r,maximumFractionDigits:r};return Object.assign(l,this.options.ticks.format),ne(t,s,l)},logarithmic(t,e,i){if(0===t)return"0";const s=i[e].significand||t/Math.pow(10,Math.floor(z(t)));return[1,2,3,5,10,15].includes(s)||e>.8*i.length?oe.numeric.call(this,t,e,i):""}};var ae={formatters:oe};const re=Object.create(null),le=Object.create(null);function he(t,e){if(!e)return t;const i=e.split(".");for(let e=0,s=i.length;e<s;++e){const s=i[e];t=t[s]||(t[s]=Object.create(null))}return t}function ce(t,e,i){return"string"==typeof e?x(he(t,e),i):x(he(t,""),e)}class de{constructor(t,e){this.animation=void 0,this.backgroundColor="rgba(0,0,0,0.1)",this.borderColor="rgba(0,0,0,0.1)",this.color="#666",this.datasets={},this.devicePixelRatio=t=>t.chart.platform.getDevicePixelRatio(),this.elements={},this.events=["mousemove","mouseout","click","touchstart","touchmove"],this.font={family:"'Helvetica Neue', 'Helvetica', 'Arial', sans-serif",size:12,style:"normal",lineHeight:1.2,weight:null},this.hover={},this.hoverBackgroundColor=(t,e)=>te(e.backgroundColor),this.hoverBorderColor=(t,e)=>te(e.borderColor),this.hoverColor=(t,e)=>te(e.color),this.indexAxis="x",this.interaction={mode:"nearest",intersect:!0,includeInvisible:!1},this.maintainAspectRatio=!0,this.onHover=null,this.onClick=null,this.parsing=!0,this.plugins={},this.responsive=!0,this.scale=void 0,this.scales={},this.showLine=!0,this.drawActiveElementsOnTop=!0,this.describe(t),this.apply(e)}set(t,e){return ce(this,t,e)}get(t){return he(this,t)}describe(t,e){return ce(le,t,e)}override(t,e){return ce(re,t,e)}route(t,e,i,s){const n=he(this,t),a=he(this,i),r="_"+e;Object.defineProperties(n,{[r]:{value:n[e],writable:!0},[e]:{enumerable:!0,get(){const t=this[r],e=a[s];return o(t)?Object.assign({},e,t):l(t,e)},set(t){this[r]=t}}})}apply(t){t.forEach((t=>t(this)))}}var ue=new de({_scriptable:t=>!t.startsWith("on"),_indexable:t=>"events"!==t,hover:{_fallback:"interaction"},interaction:{_scriptable:!1,_indexable:!1}},[function(t){t.set("animation",{delay:void 0,duration:1e3,easing:"easeOutQuart",fn:void 0,from:void 0,loop:void 0,to:void 0,type:void 0}),t.describe("animation",{_fallback:!1,_indexable:!1,_scriptable:t=>"onProgress"!==t&&"onComplete"!==t&&"fn"!==t}),t.set("animations",{colors:{type:"color",properties:ie},numbers:{type:"number",properties:ee}}),t.describe("animations",{_fallback:"animation"}),t.set("transitions",{active:{animation:{duration:400}},resize:{animation:{duration:0}},show:{animations:{colors:{from:"transparent"},visible:{type:"boolean",duration:0}}},hide:{animations:{colors:{to:"transparent"},visible:{type:"boolean",easing:"linear",fn:t=>0|t}}}})},function(t){t.set("layout",{autoPadding:!0,padding:{top:0,right:0,bottom:0,left:0}})},function(t){t.set("scale",{display:!0,offset:!1,reverse:!1,beginAtZero:!1,bounds:"ticks",clip:!0,grace:0,grid:{display:!0,lineWidth:1,drawOnChartArea:!0,drawTicks:!0,tickLength:8,tickWidth:(t,e)=>e.lineWidth,tickColor:(t,e)=>e.color,offset:!1},border:{display:!0,dash:[],dashOffset:0,width:1},title:{display:!1,text:"",padding:{top:4,bottom:4}},ticks:{minRotation:0,maxRotation:50,mirror:!1,textStrokeWidth:0,textStrokeColor:"",padding:3,display:!0,autoSkip:!0,autoSkipPadding:3,labelOffset:0,callback:ae.formatters.values,minor:{},major:{},align:"center",crossAlign:"near",showLabelBackdrop:!1,backdropColor:"rgba(255, 255, 255, 0.75)",backdropPadding:2}}),t.route("scale.ticks","color","","color"),t.route("scale.grid","color","","borderColor"),t.route("scale.border","color","","borderColor"),t.route("scale.title","color","","color"),t.describe("scale",{_fallback:!1,_scriptable:t=>!t.startsWith("before")&&!t.startsWith("after")&&"callback"!==t&&"parser"!==t,_indexable:t=>"borderDash"!==t&&"tickBorderDash"!==t&&"dash"!==t}),t.describe("scales",{_fallback:"scale"}),t.describe("scale.ticks",{_scriptable:t=>"backdropPadding"!==t&&"callback"!==t,_indexable:t=>"backdropPadding"!==t})}]);function fe(){return"undefined"!=typeof window&&"undefined"!=typeof document}function ge(t){let e=t.parentNode;return e&&"[object ShadowRoot]"===e.toString()&&(e=e.host),e}function pe(t,e,i){let s;return"string"==typeof t?(s=parseInt(t,10),-1!==t.indexOf("%")&&(s=s/100*e.parentNode[i])):s=t,s}const me=t=>t.ownerDocument.defaultView.getComputedStyle(t,null);function xe(t,e){return me(t).getPropertyValue(e)}const be=["top","right","bottom","left"];function _e(t,e,i){const s={};i=i?"-"+i:"";for(let n=0;n<4;n++){const o=be[n];s[o]=parseFloat(t[e+"-"+o+i])||0}return s.width=s.left+s.right,s.height=s.top+s.bottom,s}const ye=(t,e,i)=>(t>0||e>0)&&(!i||!i.shadowRoot);function ve(t,e){if("native"in t)return t;const{canvas:i,currentDevicePixelRatio:s}=e,n=me(i),o="border-box"===n.boxSizing,a=_e(n,"padding"),r=_e(n,"border","width"),{x:l,y:h,box:c}=function(t,e){const i=t.touches,s=i&&i.length?i[0]:t,{offsetX:n,offsetY:o}=s;let a,r,l=!1;if(ye(n,o,t.target))a=n,r=o;else{const t=e.getBoundingClientRect();a=s.clientX-t.left,r=s.clientY-t.top,l=!0}return{x:a,y:r,box:l}}(t,i),d=a.left+(c&&r.left),u=a.top+(c&&r.top);let{width:f,height:g}=e;return o&&(f-=a.width+r.width,g-=a.height+r.height),{x:Math.round((l-d)/f*i.width/s),y:Math.round((h-u)/g*i.height/s)}}const Me=t=>Math.round(10*t)/10;function we(t,e,i,s){const n=me(t),o=_e(n,"margin"),a=pe(n.maxWidth,t,"clientWidth")||T,r=pe(n.maxHeight,t,"clientHeight")||T,l=function(t,e,i){let s,n;if(void 0===e||void 0===i){const o=t&&ge(t);if(o){const t=o.getBoundingClientRect(),a=me(o),r=_e(a,"border","width"),l=_e(a,"padding");e=t.width-l.width-r.width,i=t.height-l.height-r.height,s=pe(a.maxWidth,o,"clientWidth"),n=pe(a.maxHeight,o,"clientHeight")}else e=t.clientWidth,i=t.clientHeight}return{width:e,height:i,maxWidth:s||T,maxHeight:n||T}}(t,e,i);let{width:h,height:c}=l;if("content-box"===n.boxSizing){const t=_e(n,"border","width"),e=_e(n,"padding");h-=e.width+t.width,c-=e.height+t.height}h=Math.max(0,h-o.width),c=Math.max(0,s?h/s:c-o.height),h=Me(Math.min(h,a,l.maxWidth)),c=Me(Math.min(c,r,l.maxHeight)),h&&!c&&(c=Me(h/2));return(void 0!==e||void 0!==i)&&s&&l.height&&c>l.height&&(c=l.height,h=Me(Math.floor(c*s))),{width:h,height:c}}function ke(t,e,i){const s=e||1,n=Math.floor(t.height*s),o=Math.floor(t.width*s);t.height=Math.floor(t.height),t.width=Math.floor(t.width);const a=t.canvas;return a.style&&(i||!a.style.height&&!a.style.width)&&(a.style.height=`${t.height}px`,a.style.width=`${t.width}px`),(t.currentDevicePixelRatio!==s||a.height!==n||a.width!==o)&&(t.currentDevicePixelRatio=s,a.height=n,a.width=o,t.ctx.setTransform(s,0,0,s,0,0),!0)}const Se=function(){let t=!1;try{const e={get passive(){return t=!0,!1}};fe()&&(window.addEventListener("test",null,e),window.removeEventListener("test",null,e))}catch(t){}return t}();function Pe(t,e){const i=xe(t,e),s=i&&i.match(/^(\d+)(\.\d+)?px$/);return s?+s[1]:void 0}function De(t){return!t||s(t.size)||s(t.family)?null:(t.style?t.style+" ":"")+(t.weight?t.weight+" ":"")+t.size+"px "+t.family}function Ce(t,e,i,s,n){let o=e[n];return o||(o=e[n]=t.measureText(n).width,i.push(n)),o>s&&(s=o),s}function Oe(t,e,i,s){let o=(s=s||{}).data=s.data||{},a=s.garbageCollect=s.garbageCollect||[];s.font!==e&&(o=s.data={},a=s.garbageCollect=[],s.font=e),t.save(),t.font=e;let r=0;const l=i.length;let h,c,d,u,f;for(h=0;h<l;h++)if(u=i[h],null==u||n(u)){if(n(u))for(c=0,d=u.length;c<d;c++)f=u[c],null==f||n(f)||(r=Ce(t,o,a,r,f))}else r=Ce(t,o,a,r,u);t.restore();const g=a.length/2;if(g>i.length){for(h=0;h<g;h++)delete o[a[h]];a.splice(0,g)}return r}function Ae(t,e,i){const s=t.currentDevicePixelRatio,n=0!==i?Math.max(i/2,.5):0;return Math.round((e-n)*s)/s+n}function Te(t,e){(e||t)&&((e=e||t.getContext("2d")).save(),e.resetTransform(),e.clearRect(0,0,t.width,t.height),e.restore())}function Le(t,e,i,s){Ee(t,e,i,s,null)}function Ee(t,e,i,s,n){let o,a,r,l,h,c,d,u;const f=e.pointStyle,g=e.rotation,p=e.radius;let m=(g||0)*L;if(f&&"object"==typeof f&&(o=f.toString(),"[object HTMLImageElement]"===o||"[object HTMLCanvasElement]"===o))return t.save(),t.translate(i,s),t.rotate(m),t.drawImage(f,-f.width/2,-f.height/2,f.width,f.height),void t.restore();if(!(isNaN(p)||p<=0)){switch(t.beginPath(),f){default:n?t.ellipse(i,s,n/2,p,0,0,O):t.arc(i,s,p,0,O),t.closePath();break;case"triangle":c=n?n/2:p,t.moveTo(i+Math.sin(m)*c,s-Math.cos(m)*p),m+=I,t.lineTo(i+Math.sin(m)*c,s-Math.cos(m)*p),m+=I,t.lineTo(i+Math.sin(m)*c,s-Math.cos(m)*p),t.closePath();break;case"rectRounded":h=.516*p,l=p-h,a=Math.cos(m+R)*l,d=Math.cos(m+R)*(n?n/2-h:l),r=Math.sin(m+R)*l,u=Math.sin(m+R)*(n?n/2-h:l),t.arc(i-d,s-r,h,m-C,m-E),t.arc(i+u,s-a,h,m-E,m),t.arc(i+d,s+r,h,m,m+E),t.arc(i-u,s+a,h,m+E,m+C),t.closePath();break;case"rect":if(!g){l=Math.SQRT1_2*p,c=n?n/2:l,t.rect(i-c,s-l,2*c,2*l);break}m+=R;case"rectRot":d=Math.cos(m)*(n?n/2:p),a=Math.cos(m)*p,r=Math.sin(m)*p,u=Math.sin(m)*(n?n/2:p),t.moveTo(i-d,s-r),t.lineTo(i+u,s-a),t.lineTo(i+d,s+r),t.lineTo(i-u,s+a),t.closePath();break;case"crossRot":m+=R;case"cross":d=Math.cos(m)*(n?n/2:p),a=Math.cos(m)*p,r=Math.sin(m)*p,u=Math.sin(m)*(n?n/2:p),t.moveTo(i-d,s-r),t.lineTo(i+d,s+r),t.moveTo(i+u,s-a),t.lineTo(i-u,s+a);break;case"star":d=Math.cos(m)*(n?n/2:p),a=Math.cos(m)*p,r=Math.sin(m)*p,u=Math.sin(m)*(n?n/2:p),t.moveTo(i-d,s-r),t.lineTo(i+d,s+r),t.moveTo(i+u,s-a),t.lineTo(i-u,s+a),m+=R,d=Math.cos(m)*(n?n/2:p),a=Math.cos(m)*p,r=Math.sin(m)*p,u=Math.sin(m)*(n?n/2:p),t.moveTo(i-d,s-r),t.lineTo(i+d,s+r),t.moveTo(i+u,s-a),t.lineTo(i-u,s+a);break;case"line":a=n?n/2:Math.cos(m)*p,r=Math.sin(m)*p,t.moveTo(i-a,s-r),t.lineTo(i+a,s+r);break;case"dash":t.moveTo(i,s),t.lineTo(i+Math.cos(m)*(n?n/2:p),s+Math.sin(m)*p);break;case!1:t.closePath()}t.fill(),e.borderWidth>0&&t.stroke()}}function Re(t,e,i){return i=i||.5,!e||t&&t.x>e.left-i&&t.x<e.right+i&&t.y>e.top-i&&t.y<e.bottom+i}function Ie(t,e){t.save(),t.beginPath(),t.rect(e.left,e.top,e.right-e.left,e.bottom-e.top),t.clip()}function ze(t){t.restore()}function Fe(t,e,i,s,n){if(!e)return t.lineTo(i.x,i.y);if("middle"===n){const s=(e.x+i.x)/2;t.lineTo(s,e.y),t.lineTo(s,i.y)}else"after"===n!=!!s?t.lineTo(e.x,i.y):t.lineTo(i.x,e.y);t.lineTo(i.x,i.y)}function Ve(t,e,i,s){if(!e)return t.lineTo(i.x,i.y);t.bezierCurveTo(s?e.cp1x:e.cp2x,s?e.cp1y:e.cp2y,s?i.cp2x:i.cp1x,s?i.cp2y:i.cp1y,i.x,i.y)}function Be(t,e,i,s,n){if(n.strikethrough||n.underline){const o=t.measureText(s),a=e-o.actualBoundingBoxLeft,r=e+o.actualBoundingBoxRight,l=i-o.actualBoundingBoxAscent,h=i+o.actualBoundingBoxDescent,c=n.strikethrough?(l+h)/2:h;t.strokeStyle=t.fillStyle,t.beginPath(),t.lineWidth=n.decorationWidth||2,t.moveTo(a,c),t.lineTo(r,c),t.stroke()}}function We(t,e){const i=t.fillStyle;t.fillStyle=e.color,t.fillRect(e.left,e.top,e.width,e.height),t.fillStyle=i}function Ne(t,e,i,o,a,r={}){const l=n(e)?e:[e],h=r.strokeWidth>0&&""!==r.strokeColor;let c,d;for(t.save(),t.font=a.string,function(t,e){e.translation&&t.translate(e.translation[0],e.translation[1]),s(e.rotation)||t.rotate(e.rotation),e.color&&(t.fillStyle=e.color),e.textAlign&&(t.textAlign=e.textAlign),e.textBaseline&&(t.textBaseline=e.textBaseline)}(t,r),c=0;c<l.length;++c)d=l[c],r.backdrop&&We(t,r.backdrop),h&&(r.strokeColor&&(t.strokeStyle=r.strokeColor),s(r.strokeWidth)||(t.lineWidth=r.strokeWidth),t.strokeText(d,i,o,r.maxWidth)),t.fillText(d,i,o,r.maxWidth),Be(t,i,o,d,r),o+=Number(a.lineHeight);t.restore()}function He(t,e){const{x:i,y:s,w:n,h:o,radius:a}=e;t.arc(i+a.topLeft,s+a.topLeft,a.topLeft,1.5*C,C,!0),t.lineTo(i,s+o-a.bottomLeft),t.arc(i+a.bottomLeft,s+o-a.bottomLeft,a.bottomLeft,C,E,!0),t.lineTo(i+n-a.bottomRight,s+o),t.arc(i+n-a.bottomRight,s+o-a.bottomRight,a.bottomRight,E,0,!0),t.lineTo(i+n,s+a.topRight),t.arc(i+n-a.topRight,s+a.topRight,a.topRight,0,-E,!0),t.lineTo(i+a.topLeft,s)}function je(t,e=[""],i,s,n=(()=>t[0])){const o=i||t;void 0===s&&(s=ti("_fallback",t));const a={[Symbol.toStringTag]:"Object",_cacheable:!0,_scopes:t,_rootScopes:o,_fallback:s,_getTarget:n,override:i=>je([i,...t],e,o,s)};return new Proxy(a,{deleteProperty:(e,i)=>(delete e[i],delete e._keys,delete t[0][i],!0),get:(i,s)=>qe(i,s,(()=>function(t,e,i,s){let n;for(const o of e)if(n=ti(Ue(o,t),i),void 0!==n)return Xe(t,n)?Je(i,s,t,n):n}(s,e,t,i))),getOwnPropertyDescriptor:(t,e)=>Reflect.getOwnPropertyDescriptor(t._scopes[0],e),getPrototypeOf:()=>Reflect.getPrototypeOf(t[0]),has:(t,e)=>ei(t).includes(e),ownKeys:t=>ei(t),set(t,e,i){const s=t._storage||(t._storage=n());return t[e]=s[e]=i,delete t._keys,!0}})}function $e(t,e,i,s){const a={_cacheable:!1,_proxy:t,_context:e,_subProxy:i,_stack:new Set,_descriptors:Ye(t,s),setContext:e=>$e(t,e,i,s),override:n=>$e(t.override(n),e,i,s)};return new Proxy(a,{deleteProperty:(e,i)=>(delete e[i],delete t[i],!0),get:(t,e,i)=>qe(t,e,(()=>function(t,e,i){const{_proxy:s,_context:a,_subProxy:r,_descriptors:l}=t;let h=s[e];S(h)&&l.isScriptable(e)&&(h=function(t,e,i,s){const{_proxy:n,_context:o,_subProxy:a,_stack:r}=i;if(r.has(t))throw new Error("Recursion detected: "+Array.from(r).join("->")+"->"+t);r.add(t);let l=e(o,a||s);r.delete(t),Xe(t,l)&&(l=Je(n._scopes,n,t,l));return l}(e,h,t,i));n(h)&&h.length&&(h=function(t,e,i,s){const{_proxy:n,_context:a,_subProxy:r,_descriptors:l}=i;if(void 0!==a.index&&s(t))return e[a.index%e.length];if(o(e[0])){const i=e,s=n._scopes.filter((t=>t!==i));e=[];for(const o of i){const i=Je(s,n,t,o);e.push($e(i,a,r&&r[t],l))}}return e}(e,h,t,l.isIndexable));Xe(e,h)&&(h=$e(h,a,r&&r[e],l));return h}(t,e,i))),getOwnPropertyDescriptor:(e,i)=>e._descriptors.allKeys?Reflect.has(t,i)?{enumerable:!0,configurable:!0}:void 0:Reflect.getOwnPropertyDescriptor(t,i),getPrototypeOf:()=>Reflect.getPrototypeOf(t),has:(e,i)=>Reflect.has(t,i),ownKeys:()=>Reflect.ownKeys(t),set:(e,i,s)=>(t[i]=s,delete e[i],!0)})}function Ye(t,e={scriptable:!0,indexable:!0}){const{_scriptable:i=e.scriptable,_indexable:s=e.indexable,_allKeys:n=e.allKeys}=t;return{allKeys:n,scriptable:i,indexable:s,isScriptable:S(i)?i:()=>i,isIndexable:S(s)?s:()=>s}}const Ue=(t,e)=>t?t+w(e):e,Xe=(t,e)=>o(e)&&"adapters"!==t&&(null===Object.getPrototypeOf(e)||e.constructor===Object);function qe(t,e,i){if(Object.prototype.hasOwnProperty.call(t,e)||"constructor"===e)return t[e];const s=i();return t[e]=s,s}function Ke(t,e,i){return S(t)?t(e,i):t}const Ge=(t,e)=>!0===t?e:"string"==typeof t?M(e,t):void 0;function Ze(t,e,i,s,n){for(const o of e){const e=Ge(i,o);if(e){t.add(e);const o=Ke(e._fallback,i,n);if(void 0!==o&&o!==i&&o!==s)return o}else if(!1===e&&void 0!==s&&i!==s)return null}return!1}function Je(t,e,i,s){const a=e._rootScopes,r=Ke(e._fallback,i,s),l=[...t,...a],h=new Set;h.add(s);let c=Qe(h,l,i,r||i,s);return null!==c&&((void 0===r||r===i||(c=Qe(h,l,r,c,s),null!==c))&&je(Array.from(h),[""],a,r,(()=>function(t,e,i){const s=t._getTarget();e in s||(s[e]={});const a=s[e];if(n(a)&&o(i))return i;return a||{}}(e,i,s))))}function Qe(t,e,i,s,n){for(;i;)i=Ze(t,e,i,s,n);return i}function ti(t,e){for(const i of e){if(!i)continue;const e=i[t];if(void 0!==e)return e}}function ei(t){let e=t._keys;return e||(e=t._keys=function(t){const e=new Set;for(const i of t)for(const t of Object.keys(i).filter((t=>!t.startsWith("_"))))e.add(t);return Array.from(e)}(t._scopes)),e}function ii(t,e,i,s){const{iScale:n}=t,{key:o="r"}=this._parsing,a=new Array(s);let r,l,h,c;for(r=0,l=s;r<l;++r)h=r+i,c=e[h],a[r]={r:n.parse(M(c,o),h)};return a}const si=Number.EPSILON||1e-14,ni=(t,e)=>e<t.length&&!t[e].skip&&t[e],oi=t=>"x"===t?"y":"x";function ai(t,e,i,s){const n=t.skip?e:t,o=e,a=i.skip?e:i,r=q(o,n),l=q(a,o);let h=r/(r+l),c=l/(r+l);h=isNaN(h)?0:h,c=isNaN(c)?0:c;const d=s*h,u=s*c;return{previous:{x:o.x-d*(a.x-n.x),y:o.y-d*(a.y-n.y)},next:{x:o.x+u*(a.x-n.x),y:o.y+u*(a.y-n.y)}}}function ri(t,e="x"){const i=oi(e),s=t.length,n=Array(s).fill(0),o=Array(s);let a,r,l,h=ni(t,0);for(a=0;a<s;++a)if(r=l,l=h,h=ni(t,a+1),l){if(h){const t=h[e]-l[e];n[a]=0!==t?(h[i]-l[i])/t:0}o[a]=r?h?F(n[a-1])!==F(n[a])?0:(n[a-1]+n[a])/2:n[a-1]:n[a]}!function(t,e,i){const s=t.length;let n,o,a,r,l,h=ni(t,0);for(let c=0;c<s-1;++c)l=h,h=ni(t,c+1),l&&h&&(V(e[c],0,si)?i[c]=i[c+1]=0:(n=i[c]/e[c],o=i[c+1]/e[c],r=Math.pow(n,2)+Math.pow(o,2),r<=9||(a=3/Math.sqrt(r),i[c]=n*a*e[c],i[c+1]=o*a*e[c])))}(t,n,o),function(t,e,i="x"){const s=oi(i),n=t.length;let o,a,r,l=ni(t,0);for(let h=0;h<n;++h){if(a=r,r=l,l=ni(t,h+1),!r)continue;const n=r[i],c=r[s];a&&(o=(n-a[i])/3,r[`cp1${i}`]=n-o,r[`cp1${s}`]=c-o*e[h]),l&&(o=(l[i]-n)/3,r[`cp2${i}`]=n+o,r[`cp2${s}`]=c+o*e[h])}}(t,o,e)}function li(t,e,i){return Math.max(Math.min(t,i),e)}function hi(t,e,i,s,n){let o,a,r,l;if(e.spanGaps&&(t=t.filter((t=>!t.skip))),"monotone"===e.cubicInterpolationMode)ri(t,n);else{let i=s?t[t.length-1]:t[0];for(o=0,a=t.length;o<a;++o)r=t[o],l=ai(i,r,t[Math.min(o+1,a-(s?0:1))%a],e.tension),r.cp1x=l.previous.x,r.cp1y=l.previous.y,r.cp2x=l.next.x,r.cp2y=l.next.y,i=r}e.capBezierPoints&&function(t,e){let i,s,n,o,a,r=Re(t[0],e);for(i=0,s=t.length;i<s;++i)a=o,o=r,r=i<s-1&&Re(t[i+1],e),o&&(n=t[i],a&&(n.cp1x=li(n.cp1x,e.left,e.right),n.cp1y=li(n.cp1y,e.top,e.bottom)),r&&(n.cp2x=li(n.cp2x,e.left,e.right),n.cp2y=li(n.cp2y,e.top,e.bottom)))}(t,i)}const ci=t=>0===t||1===t,di=(t,e,i)=>-Math.pow(2,10*(t-=1))*Math.sin((t-e)*O/i),ui=(t,e,i)=>Math.pow(2,-10*t)*Math.sin((t-e)*O/i)+1,fi={linear:t=>t,easeInQuad:t=>t*t,easeOutQuad:t=>-t*(t-2),easeInOutQuad:t=>(t/=.5)<1?.5*t*t:-.5*(--t*(t-2)-1),easeInCubic:t=>t*t*t,easeOutCubic:t=>(t-=1)*t*t+1,easeInOutCubic:t=>(t/=.5)<1?.5*t*t*t:.5*((t-=2)*t*t+2),easeInQuart:t=>t*t*t*t,easeOutQuart:t=>-((t-=1)*t*t*t-1),easeInOutQuart:t=>(t/=.5)<1?.5*t*t*t*t:-.5*((t-=2)*t*t*t-2),easeInQuint:t=>t*t*t*t*t,easeOutQuint:t=>(t-=1)*t*t*t*t+1,easeInOutQuint:t=>(t/=.5)<1?.5*t*t*t*t*t:.5*((t-=2)*t*t*t*t+2),easeInSine:t=>1-Math.cos(t*E),easeOutSine:t=>Math.sin(t*E),easeInOutSine:t=>-.5*(Math.cos(C*t)-1),easeInExpo:t=>0===t?0:Math.pow(2,10*(t-1)),easeOutExpo:t=>1===t?1:1-Math.pow(2,-10*t),easeInOutExpo:t=>ci(t)?t:t<.5?.5*Math.pow(2,10*(2*t-1)):.5*(2-Math.pow(2,-10*(2*t-1))),easeInCirc:t=>t>=1?t:-(Math.sqrt(1-t*t)-1),easeOutCirc:t=>Math.sqrt(1-(t-=1)*t),easeInOutCirc:t=>(t/=.5)<1?-.5*(Math.sqrt(1-t*t)-1):.5*(Math.sqrt(1-(t-=2)*t)+1),easeInElastic:t=>ci(t)?t:di(t,.075,.3),easeOutElastic:t=>ci(t)?t:ui(t,.075,.3),easeInOutElastic(t){const e=.1125;return ci(t)?t:t<.5?.5*di(2*t,e,.45):.5+.5*ui(2*t-1,e,.45)},easeInBack(t){const e=1.70158;return t*t*((e+1)*t-e)},easeOutBack(t){const e=1.70158;return(t-=1)*t*((e+1)*t+e)+1},easeInOutBack(t){let e=1.70158;return(t/=.5)<1?t*t*((1+(e*=1.525))*t-e)*.5:.5*((t-=2)*t*((1+(e*=1.525))*t+e)+2)},easeInBounce:t=>1-fi.easeOutBounce(1-t),easeOutBounce(t){const e=7.5625,i=2.75;return t<1/i?e*t*t:t<2/i?e*(t-=1.5/i)*t+.75:t<2.5/i?e*(t-=2.25/i)*t+.9375:e*(t-=2.625/i)*t+.984375},easeInOutBounce:t=>t<.5?.5*fi.easeInBounce(2*t):.5*fi.easeOutBounce(2*t-1)+.5};function gi(t,e,i,s){return{x:t.x+i*(e.x-t.x),y:t.y+i*(e.y-t.y)}}function pi(t,e,i,s){return{x:t.x+i*(e.x-t.x),y:"middle"===s?i<.5?t.y:e.y:"after"===s?i<1?t.y:e.y:i>0?e.y:t.y}}function mi(t,e,i,s){const n={x:t.cp2x,y:t.cp2y},o={x:e.cp1x,y:e.cp1y},a=gi(t,n,i),r=gi(n,o,i),l=gi(o,e,i),h=gi(a,r,i),c=gi(r,l,i);return gi(h,c,i)}const xi=/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/,bi=/^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/;function _i(t,e){const i=(""+t).match(xi);if(!i||"normal"===i[1])return 1.2*e;switch(t=+i[2],i[3]){case"px":return t;case"%":t/=100}return e*t}const yi=t=>+t||0;function vi(t,e){const i={},s=o(e),n=s?Object.keys(e):e,a=o(t)?s?i=>l(t[i],t[e[i]]):e=>t[e]:()=>t;for(const t of n)i[t]=yi(a(t));return i}function Mi(t){return vi(t,{top:"y",right:"x",bottom:"y",left:"x"})}function wi(t){return vi(t,["topLeft","topRight","bottomLeft","bottomRight"])}function ki(t){const e=Mi(t);return e.width=e.left+e.right,e.height=e.top+e.bottom,e}function Si(t,e){t=t||{},e=e||ue.font;let i=l(t.size,e.size);"string"==typeof i&&(i=parseInt(i,10));let s=l(t.style,e.style);s&&!(""+s).match(bi)&&(console.warn('Invalid font style specified: "'+s+'"'),s=void 0);const n={family:l(t.family,e.family),lineHeight:_i(l(t.lineHeight,e.lineHeight),i),size:i,style:s,weight:l(t.weight,e.weight),string:""};return n.string=De(n),n}function Pi(t,e,i,s){let o,a,r,l=!0;for(o=0,a=t.length;o<a;++o)if(r=t[o],void 0!==r&&(void 0!==e&&"function"==typeof r&&(r=r(e),l=!1),void 0!==i&&n(r)&&(r=r[i%r.length],l=!1),void 0!==r))return s&&!l&&(s.cacheable=!1),r}function Di(t,e,i){const{min:s,max:n}=t,o=c(e,(n-s)/2),a=(t,e)=>i&&0===t?0:t+e;return{min:a(s,-Math.abs(o)),max:a(n,o)}}function Ci(t,e){return Object.assign(Object.create(t),e)}function Oi(t,e,i){return t?function(t,e){return{x:i=>t+t+e-i,setWidth(t){e=t},textAlign:t=>"center"===t?t:"right"===t?"left":"right",xPlus:(t,e)=>t-e,leftForLtr:(t,e)=>t-e}}(e,i):{x:t=>t,setWidth(t){},textAlign:t=>t,xPlus:(t,e)=>t+e,leftForLtr:(t,e)=>t}}function Ai(t,e){let i,s;"ltr"!==e&&"rtl"!==e||(i=t.canvas.style,s=[i.getPropertyValue("direction"),i.getPropertyPriority("direction")],i.setProperty("direction",e,"important"),t.prevTextDirection=s)}function Ti(t,e){void 0!==e&&(delete t.prevTextDirection,t.canvas.style.setProperty("direction",e[0],e[1]))}function Li(t){return"angle"===t?{between:Z,compare:K,normalize:G}:{between:tt,compare:(t,e)=>t-e,normalize:t=>t}}function Ei({start:t,end:e,count:i,loop:s,style:n}){return{start:t%i,end:e%i,loop:s&&(e-t+1)%i==0,style:n}}function Ri(t,e,i){if(!i)return[t];const{property:s,start:n,end:o}=i,a=e.length,{compare:r,between:l,normalize:h}=Li(s),{start:c,end:d,loop:u,style:f}=function(t,e,i){const{property:s,start:n,end:o}=i,{between:a,normalize:r}=Li(s),l=e.length;let h,c,{start:d,end:u,loop:f}=t;if(f){for(d+=l,u+=l,h=0,c=l;h<c&&a(r(e[d%l][s]),n,o);++h)d--,u--;d%=l,u%=l}return u<d&&(u+=l),{start:d,end:u,loop:f,style:t.style}}(t,e,i),g=[];let p,m,x,b=!1,_=null;const y=()=>b||l(n,x,p)&&0!==r(n,x),v=()=>!b||0===r(o,p)||l(o,x,p);for(let t=c,i=c;t<=d;++t)m=e[t%a],m.skip||(p=h(m[s]),p!==x&&(b=l(p,n,o),null===_&&y()&&(_=0===r(p,n)?t:i),null!==_&&v()&&(g.push(Ei({start:_,end:t,loop:u,count:a,style:f})),_=null),i=t,x=p));return null!==_&&g.push(Ei({start:_,end:d,loop:u,count:a,style:f})),g}function Ii(t,e){const i=[],s=t.segments;for(let n=0;n<s.length;n++){const o=Ri(s[n],t.points,e);o.length&&i.push(...o)}return i}function zi(t,e){const i=t.points,s=t.options.spanGaps,n=i.length;if(!n)return[];const o=!!t._loop,{start:a,end:r}=function(t,e,i,s){let n=0,o=e-1;if(i&&!s)for(;n<e&&!t[n].skip;)n++;for(;n<e&&t[n].skip;)n++;for(n%=e,i&&(o+=n);o>n&&t[o%e].skip;)o--;return o%=e,{start:n,end:o}}(i,n,o,s);if(!0===s)return Fi(t,[{start:a,end:r,loop:o}],i,e);return Fi(t,function(t,e,i,s){const n=t.length,o=[];let a,r=e,l=t[e];for(a=e+1;a<=i;++a){const i=t[a%n];i.skip||i.stop?l.skip||(s=!1,o.push({start:e%n,end:(a-1)%n,loop:s}),e=r=i.stop?a:null):(r=a,l.skip&&(e=a)),l=i}return null!==r&&o.push({start:e%n,end:r%n,loop:s}),o}(i,a,r<a?r+n:r,!!t._fullLoop&&0===a&&r===n-1),i,e)}function Fi(t,e,i,s){return s&&s.setContext&&i?function(t,e,i,s){const n=t._chart.getContext(),o=Vi(t.options),{_datasetIndex:a,options:{spanGaps:r}}=t,l=i.length,h=[];let c=o,d=e[0].start,u=d;function f(t,e,s,n){const o=r?-1:1;if(t!==e){for(t+=l;i[t%l].skip;)t-=o;for(;i[e%l].skip;)e+=o;t%l!=e%l&&(h.push({start:t%l,end:e%l,loop:s,style:n}),c=n,d=e%l)}}for(const t of e){d=r?d:t.start;let e,o=i[d%l];for(u=d+1;u<=t.end;u++){const r=i[u%l];e=Vi(s.setContext(Ci(n,{type:"segment",p0:o,p1:r,p0DataIndex:(u-1)%l,p1DataIndex:u%l,datasetIndex:a}))),Bi(e,c)&&f(d,u-1,t.loop,c),o=r,c=e}d<u-1&&f(d,u-1,t.loop,c)}return h}(t,e,i,s):e}function Vi(t){return{backgroundColor:t.backgroundColor,borderCapStyle:t.borderCapStyle,borderDash:t.borderDash,borderDashOffset:t.borderDashOffset,borderJoinStyle:t.borderJoinStyle,borderWidth:t.borderWidth,borderColor:t.borderColor}}function Bi(t,e){if(!e)return!1;const i=[],s=function(t,e){return Jt(e)?(i.includes(e)||i.push(e),i.indexOf(e)):e};return JSON.stringify(t,s)!==JSON.stringify(e,s)}var Wi=Object.freeze({__proto__:null,HALF_PI:E,INFINITY:T,PI:C,PITAU:A,QUARTER_PI:R,RAD_PER_DEG:L,TAU:O,TWO_THIRDS_PI:I,_addGrace:Di,_alignPixel:Ae,_alignStartEnd:ft,_angleBetween:Z,_angleDiff:K,_arrayUnique:lt,_attachContext:$e,_bezierCurveTo:Ve,_bezierInterpolation:mi,_boundSegment:Ri,_boundSegments:Ii,_capitalize:w,_computeSegments:zi,_createResolver:je,_decimalPlaces:U,_deprecated:function(t,e,i,s){void 0!==e&&console.warn(t+': "'+i+'" is deprecated. Please use "'+s+'" instead')},_descriptors:Ye,_elementsEqual:f,_factorize:W,_filterBetween:nt,_getParentNode:ge,_getStartAndCountOfVisiblePoints:pt,_int16Range:Q,_isBetween:tt,_isClickEvent:D,_isDomSupported:fe,_isPointInArea:Re,_limitValue:J,_longestText:Oe,_lookup:et,_lookupByKey:it,_measureText:Ce,_merger:m,_mergerIf:_,_normalizeAngle:G,_parseObjectDataRadialScale:ii,_pointInLine:gi,_readValueToProps:vi,_rlookupByKey:st,_scaleRangesChanged:mt,_setMinAndMaxByKey:j,_splitKey:v,_steppedInterpolation:pi,_steppedLineTo:Fe,_textX:gt,_toLeftRightCenter:ut,_updateBezierControlPoints:hi,addRoundedRectPath:He,almostEquals:V,almostWhole:H,callback:d,clearCanvas:Te,clipArea:Ie,clone:g,color:Qt,createContext:Ci,debounce:dt,defined:k,distanceBetweenPoints:q,drawPoint:Le,drawPointLegend:Ee,each:u,easingEffects:fi,finiteOrDefault:r,fontString:function(t,e,i){return e+" "+t+"px "+i},formatNumber:ne,getAngleFromPoint:X,getHoverColor:te,getMaximumSize:we,getRelativePosition:ve,getRtlAdapter:Oi,getStyle:xe,isArray:n,isFinite:a,isFunction:S,isNullOrUndef:s,isNumber:N,isObject:o,isPatternOrGradient:Jt,listenArrayEvents:at,log10:z,merge:x,mergeIf:b,niceNum:B,noop:e,overrideTextDirection:Ai,readUsedSize:Pe,renderText:Ne,requestAnimFrame:ht,resolve:Pi,resolveObjectKey:M,restoreTextDirection:Ti,retinaScale:ke,setsEqual:P,sign:F,splineCurve:ai,splineCurveMonotone:ri,supportsEventListenerOptions:Se,throttled:ct,toDegrees:Y,toDimension:c,toFont:Si,toFontString:De,toLineHeight:_i,toPadding:ki,toPercentage:h,toRadians:$,toTRBL:Mi,toTRBLCorners:wi,uid:i,unclipArea:ze,unlistenArrayEvents:rt,valueOrDefault:l});function Ni(t,e,i,s){const{controller:n,data:o,_sorted:a}=t,r=n._cachedMeta.iScale;if(r&&e===r.axis&&"r"!==e&&a&&o.length){const t=r._reversePixels?st:it;if(!s)return t(o,e,i);if(n._sharedOptions){const s=o[0],n="function"==typeof s.getRange&&s.getRange(e);if(n){const s=t(o,e,i-n),a=t(o,e,i+n);return{lo:s.lo,hi:a.hi}}}}return{lo:0,hi:o.length-1}}function Hi(t,e,i,s,n){const o=t.getSortedVisibleDatasetMetas(),a=i[e];for(let t=0,i=o.length;t<i;++t){const{index:i,data:r}=o[t],{lo:l,hi:h}=Ni(o[t],e,a,n);for(let t=l;t<=h;++t){const e=r[t];e.skip||s(e,i,t)}}}function ji(t,e,i,s,n){const o=[];if(!n&&!t.isPointInArea(e))return o;return Hi(t,i,e,(function(i,a,r){(n||Re(i,t.chartArea,0))&&i.inRange(e.x,e.y,s)&&o.push({element:i,datasetIndex:a,index:r})}),!0),o}function $i(t,e,i,s,n,o){let a=[];const r=function(t){const e=-1!==t.indexOf("x"),i=-1!==t.indexOf("y");return function(t,s){const n=e?Math.abs(t.x-s.x):0,o=i?Math.abs(t.y-s.y):0;return Math.sqrt(Math.pow(n,2)+Math.pow(o,2))}}(i);let l=Number.POSITIVE_INFINITY;return Hi(t,i,e,(function(i,h,c){const d=i.inRange(e.x,e.y,n);if(s&&!d)return;const u=i.getCenterPoint(n);if(!(!!o||t.isPointInArea(u))&&!d)return;const f=r(e,u);f<l?(a=[{element:i,datasetIndex:h,index:c}],l=f):f===l&&a.push({element:i,datasetIndex:h,index:c})})),a}function Yi(t,e,i,s,n,o){return o||t.isPointInArea(e)?"r"!==i||s?$i(t,e,i,s,n,o):function(t,e,i,s){let n=[];return Hi(t,i,e,(function(t,i,o){const{startAngle:a,endAngle:r}=t.getProps(["startAngle","endAngle"],s),{angle:l}=X(t,{x:e.x,y:e.y});Z(l,a,r)&&n.push({element:t,datasetIndex:i,index:o})})),n}(t,e,i,n):[]}function Ui(t,e,i,s,n){const o=[],a="x"===i?"inXRange":"inYRange";let r=!1;return Hi(t,i,e,((t,s,l)=>{t[a]&&t[a](e[i],n)&&(o.push({element:t,datasetIndex:s,index:l}),r=r||t.inRange(e.x,e.y,n))})),s&&!r?[]:o}var Xi={evaluateInteractionItems:Hi,modes:{index(t,e,i,s){const n=ve(e,t),o=i.axis||"x",a=i.includeInvisible||!1,r=i.intersect?ji(t,n,o,s,a):Yi(t,n,o,!1,s,a),l=[];return r.length?(t.getSortedVisibleDatasetMetas().forEach((t=>{const e=r[0].index,i=t.data[e];i&&!i.skip&&l.push({element:i,datasetIndex:t.index,index:e})})),l):[]},dataset(t,e,i,s){const n=ve(e,t),o=i.axis||"xy",a=i.includeInvisible||!1;let r=i.intersect?ji(t,n,o,s,a):Yi(t,n,o,!1,s,a);if(r.length>0){const e=r[0].datasetIndex,i=t.getDatasetMeta(e).data;r=[];for(let t=0;t<i.length;++t)r.push({element:i[t],datasetIndex:e,index:t})}return r},point:(t,e,i,s)=>ji(t,ve(e,t),i.axis||"xy",s,i.includeInvisible||!1),nearest(t,e,i,s){const n=ve(e,t),o=i.axis||"xy",a=i.includeInvisible||!1;return Yi(t,n,o,i.intersect,s,a)},x:(t,e,i,s)=>Ui(t,ve(e,t),"x",i.intersect,s),y:(t,e,i,s)=>Ui(t,ve(e,t),"y",i.intersect,s)}};const qi=["left","top","right","bottom"];function Ki(t,e){return t.filter((t=>t.pos===e))}function Gi(t,e){return t.filter((t=>-1===qi.indexOf(t.pos)&&t.box.axis===e))}function Zi(t,e){return t.sort(((t,i)=>{const s=e?i:t,n=e?t:i;return s.weight===n.weight?s.index-n.index:s.weight-n.weight}))}function Ji(t,e){const i=function(t){const e={};for(const i of t){const{stack:t,pos:s,stackWeight:n}=i;if(!t||!qi.includes(s))continue;const o=e[t]||(e[t]={count:0,placed:0,weight:0,size:0});o.count++,o.weight+=n}return e}(t),{vBoxMaxWidth:s,hBoxMaxHeight:n}=e;let o,a,r;for(o=0,a=t.length;o<a;++o){r=t[o];const{fullSize:a}=r.box,l=i[r.stack],h=l&&r.stackWeight/l.weight;r.horizontal?(r.width=h?h*s:a&&e.availableWidth,r.height=n):(r.width=s,r.height=h?h*n:a&&e.availableHeight)}return i}function Qi(t,e,i,s){return Math.max(t[i],e[i])+Math.max(t[s],e[s])}function ts(t,e){t.top=Math.max(t.top,e.top),t.left=Math.max(t.left,e.left),t.bottom=Math.max(t.bottom,e.bottom),t.right=Math.max(t.right,e.right)}function es(t,e,i,s){const{pos:n,box:a}=i,r=t.maxPadding;if(!o(n)){i.size&&(t[n]-=i.size);const e=s[i.stack]||{size:0,count:1};e.size=Math.max(e.size,i.horizontal?a.height:a.width),i.size=e.size/e.count,t[n]+=i.size}a.getPadding&&ts(r,a.getPadding());const l=Math.max(0,e.outerWidth-Qi(r,t,"left","right")),h=Math.max(0,e.outerHeight-Qi(r,t,"top","bottom")),c=l!==t.w,d=h!==t.h;return t.w=l,t.h=h,i.horizontal?{same:c,other:d}:{same:d,other:c}}function is(t,e){const i=e.maxPadding;function s(t){const s={left:0,top:0,right:0,bottom:0};return t.forEach((t=>{s[t]=Math.max(e[t],i[t])})),s}return s(t?["left","right"]:["top","bottom"])}function ss(t,e,i,s){const n=[];let o,a,r,l,h,c;for(o=0,a=t.length,h=0;o<a;++o){r=t[o],l=r.box,l.update(r.width||e.w,r.height||e.h,is(r.horizontal,e));const{same:a,other:d}=es(e,i,r,s);h|=a&&n.length,c=c||d,l.fullSize||n.push(r)}return h&&ss(n,e,i,s)||c}function ns(t,e,i,s,n){t.top=i,t.left=e,t.right=e+s,t.bottom=i+n,t.width=s,t.height=n}function os(t,e,i,s){const n=i.padding;let{x:o,y:a}=e;for(const r of t){const t=r.box,l=s[r.stack]||{count:1,placed:0,weight:1},h=r.stackWeight/l.weight||1;if(r.horizontal){const s=e.w*h,o=l.size||t.height;k(l.start)&&(a=l.start),t.fullSize?ns(t,n.left,a,i.outerWidth-n.right-n.left,o):ns(t,e.left+l.placed,a,s,o),l.start=a,l.placed+=s,a=t.bottom}else{const s=e.h*h,a=l.size||t.width;k(l.start)&&(o=l.start),t.fullSize?ns(t,o,n.top,a,i.outerHeight-n.bottom-n.top):ns(t,o,e.top+l.placed,a,s),l.start=o,l.placed+=s,o=t.right}}e.x=o,e.y=a}var as={addBox(t,e){t.boxes||(t.boxes=[]),e.fullSize=e.fullSize||!1,e.position=e.position||"top",e.weight=e.weight||0,e._layers=e._layers||function(){return[{z:0,draw(t){e.draw(t)}}]},t.boxes.push(e)},removeBox(t,e){const i=t.boxes?t.boxes.indexOf(e):-1;-1!==i&&t.boxes.splice(i,1)},configure(t,e,i){e.fullSize=i.fullSize,e.position=i.position,e.weight=i.weight},update(t,e,i,s){if(!t)return;const n=ki(t.options.layout.padding),o=Math.max(e-n.width,0),a=Math.max(i-n.height,0),r=function(t){const e=function(t){const e=[];let i,s,n,o,a,r;for(i=0,s=(t||[]).length;i<s;++i)n=t[i],({position:o,options:{stack:a,stackWeight:r=1}}=n),e.push({index:i,box:n,pos:o,horizontal:n.isHorizontal(),weight:n.weight,stack:a&&o+a,stackWeight:r});return e}(t),i=Zi(e.filter((t=>t.box.fullSize)),!0),s=Zi(Ki(e,"left"),!0),n=Zi(Ki(e,"right")),o=Zi(Ki(e,"top"),!0),a=Zi(Ki(e,"bottom")),r=Gi(e,"x"),l=Gi(e,"y");return{fullSize:i,leftAndTop:s.concat(o),rightAndBottom:n.concat(l).concat(a).concat(r),chartArea:Ki(e,"chartArea"),vertical:s.concat(n).concat(l),horizontal:o.concat(a).concat(r)}}(t.boxes),l=r.vertical,h=r.horizontal;u(t.boxes,(t=>{"function"==typeof t.beforeLayout&&t.beforeLayout()}));const c=l.reduce(((t,e)=>e.box.options&&!1===e.box.options.display?t:t+1),0)||1,d=Object.freeze({outerWidth:e,outerHeight:i,padding:n,availableWidth:o,availableHeight:a,vBoxMaxWidth:o/2/c,hBoxMaxHeight:a/2}),f=Object.assign({},n);ts(f,ki(s));const g=Object.assign({maxPadding:f,w:o,h:a,x:n.left,y:n.top},n),p=Ji(l.concat(h),d);ss(r.fullSize,g,d,p),ss(l,g,d,p),ss(h,g,d,p)&&ss(l,g,d,p),function(t){const e=t.maxPadding;function i(i){const s=Math.max(e[i]-t[i],0);return t[i]+=s,s}t.y+=i("top"),t.x+=i("left"),i("right"),i("bottom")}(g),os(r.leftAndTop,g,d,p),g.x+=g.w,g.y+=g.h,os(r.rightAndBottom,g,d,p),t.chartArea={left:g.left,top:g.top,right:g.left+g.w,bottom:g.top+g.h,height:g.h,width:g.w},u(r.chartArea,(e=>{const i=e.box;Object.assign(i,t.chartArea),i.update(g.w,g.h,{left:0,top:0,right:0,bottom:0})}))}};class rs{acquireContext(t,e){}releaseContext(t){return!1}addEventListener(t,e,i){}removeEventListener(t,e,i){}getDevicePixelRatio(){return 1}getMaximumSize(t,e,i,s){return e=Math.max(0,e||t.width),i=i||t.height,{width:e,height:Math.max(0,s?Math.floor(e/s):i)}}isAttached(t){return!0}updateConfig(t){}}class ls extends rs{acquireContext(t){return t&&t.getContext&&t.getContext("2d")||null}updateConfig(t){t.options.animation=!1}}const hs="$chartjs",cs={touchstart:"mousedown",touchmove:"mousemove",touchend:"mouseup",pointerenter:"mouseenter",pointerdown:"mousedown",pointermove:"mousemove",pointerup:"mouseup",pointerleave:"mouseout",pointerout:"mouseout"},ds=t=>null===t||""===t;const us=!!Se&&{passive:!0};function fs(t,e,i){t&&t.canvas&&t.canvas.removeEventListener(e,i,us)}function gs(t,e){for(const i of t)if(i===e||i.contains(e))return!0}function ps(t,e,i){const s=t.canvas,n=new MutationObserver((t=>{let e=!1;for(const i of t)e=e||gs(i.addedNodes,s),e=e&&!gs(i.removedNodes,s);e&&i()}));return n.observe(document,{childList:!0,subtree:!0}),n}function ms(t,e,i){const s=t.canvas,n=new MutationObserver((t=>{let e=!1;for(const i of t)e=e||gs(i.removedNodes,s),e=e&&!gs(i.addedNodes,s);e&&i()}));return n.observe(document,{childList:!0,subtree:!0}),n}const xs=new Map;let bs=0;function _s(){const t=window.devicePixelRatio;t!==bs&&(bs=t,xs.forEach(((e,i)=>{i.currentDevicePixelRatio!==t&&e()})))}function ys(t,e,i){const s=t.canvas,n=s&&ge(s);if(!n)return;const o=ct(((t,e)=>{const s=n.clientWidth;i(t,e),s<n.clientWidth&&i()}),window),a=new ResizeObserver((t=>{const e=t[0],i=e.contentRect.width,s=e.contentRect.height;0===i&&0===s||o(i,s)}));return a.observe(n),function(t,e){xs.size||window.addEventListener("resize",_s),xs.set(t,e)}(t,o),a}function vs(t,e,i){i&&i.disconnect(),"resize"===e&&function(t){xs.delete(t),xs.size||window.removeEventListener("resize",_s)}(t)}function Ms(t,e,i){const s=t.canvas,n=ct((e=>{null!==t.ctx&&i(function(t,e){const i=cs[t.type]||t.type,{x:s,y:n}=ve(t,e);return{type:i,chart:e,native:t,x:void 0!==s?s:null,y:void 0!==n?n:null}}(e,t))}),t);return function(t,e,i){t&&t.addEventListener(e,i,us)}(s,e,n),n}class ws extends rs{acquireContext(t,e){const i=t&&t.getContext&&t.getContext("2d");return i&&i.canvas===t?(function(t,e){const i=t.style,s=t.getAttribute("height"),n=t.getAttribute("width");if(t[hs]={initial:{height:s,width:n,style:{display:i.display,height:i.height,width:i.width}}},i.display=i.display||"block",i.boxSizing=i.boxSizing||"border-box",ds(n)){const e=Pe(t,"width");void 0!==e&&(t.width=e)}if(ds(s))if(""===t.style.height)t.height=t.width/(e||2);else{const e=Pe(t,"height");void 0!==e&&(t.height=e)}}(t,e),i):null}releaseContext(t){const e=t.canvas;if(!e[hs])return!1;const i=e[hs].initial;["height","width"].forEach((t=>{const n=i[t];s(n)?e.removeAttribute(t):e.setAttribute(t,n)}));const n=i.style||{};return Object.keys(n).forEach((t=>{e.style[t]=n[t]})),e.width=e.width,delete e[hs],!0}addEventListener(t,e,i){this.removeEventListener(t,e);const s=t.$proxies||(t.$proxies={}),n={attach:ps,detach:ms,resize:ys}[e]||Ms;s[e]=n(t,e,i)}removeEventListener(t,e){const i=t.$proxies||(t.$proxies={}),s=i[e];if(!s)return;({attach:vs,detach:vs,resize:vs}[e]||fs)(t,e,s),i[e]=void 0}getDevicePixelRatio(){return window.devicePixelRatio}getMaximumSize(t,e,i,s){return we(t,e,i,s)}isAttached(t){const e=t&&ge(t);return!(!e||!e.isConnected)}}function ks(t){return!fe()||"undefined"!=typeof OffscreenCanvas&&t instanceof OffscreenCanvas?ls:ws}var Ss=Object.freeze({__proto__:null,BasePlatform:rs,BasicPlatform:ls,DomPlatform:ws,_detectPlatform:ks});const Ps="transparent",Ds={boolean:(t,e,i)=>i>.5?e:t,color(t,e,i){const s=Qt(t||Ps),n=s.valid&&Qt(e||Ps);return n&&n.valid?n.mix(s,i).hexString():e},number:(t,e,i)=>t+(e-t)*i};class Cs{constructor(t,e,i,s){const n=e[i];s=Pi([t.to,s,n,t.from]);const o=Pi([t.from,n,s]);this._active=!0,this._fn=t.fn||Ds[t.type||typeof o],this._easing=fi[t.easing]||fi.linear,this._start=Math.floor(Date.now()+(t.delay||0)),this._duration=this._total=Math.floor(t.duration),this._loop=!!t.loop,this._target=e,this._prop=i,this._from=o,this._to=s,this._promises=void 0}active(){return this._active}update(t,e,i){if(this._active){this._notify(!1);const s=this._target[this._prop],n=i-this._start,o=this._duration-n;this._start=i,this._duration=Math.floor(Math.max(o,t.duration)),this._total+=n,this._loop=!!t.loop,this._to=Pi([t.to,e,s,t.from]),this._from=Pi([t.from,s,e])}}cancel(){this._active&&(this.tick(Date.now()),this._active=!1,this._notify(!1))}tick(t){const e=t-this._start,i=this._duration,s=this._prop,n=this._from,o=this._loop,a=this._to;let r;if(this._active=n!==a&&(o||e<i),!this._active)return this._target[s]=a,void this._notify(!0);e<0?this._target[s]=n:(r=e/i%2,r=o&&r>1?2-r:r,r=this._easing(Math.min(1,Math.max(0,r))),this._target[s]=this._fn(n,a,r))}wait(){const t=this._promises||(this._promises=[]);return new Promise(((e,i)=>{t.push({res:e,rej:i})}))}_notify(t){const e=t?"res":"rej",i=this._promises||[];for(let t=0;t<i.length;t++)i[t][e]()}}class Os{constructor(t,e){this._chart=t,this._properties=new Map,this.configure(e)}configure(t){if(!o(t))return;const e=Object.keys(ue.animation),i=this._properties;Object.getOwnPropertyNames(t).forEach((s=>{const a=t[s];if(!o(a))return;const r={};for(const t of e)r[t]=a[t];(n(a.properties)&&a.properties||[s]).forEach((t=>{t!==s&&i.has(t)||i.set(t,r)}))}))}_animateOptions(t,e){const i=e.options,s=function(t,e){if(!e)return;let i=t.options;if(!i)return void(t.options=e);i.$shared&&(t.options=i=Object.assign({},i,{$shared:!1,$animations:{}}));return i}(t,i);if(!s)return[];const n=this._createAnimations(s,i);return i.$shared&&function(t,e){const i=[],s=Object.keys(e);for(let e=0;e<s.length;e++){const n=t[s[e]];n&&n.active()&&i.push(n.wait())}return Promise.all(i)}(t.options.$animations,i).then((()=>{t.options=i}),(()=>{})),n}_createAnimations(t,e){const i=this._properties,s=[],n=t.$animations||(t.$animations={}),o=Object.keys(e),a=Date.now();let r;for(r=o.length-1;r>=0;--r){const l=o[r];if("$"===l.charAt(0))continue;if("options"===l){s.push(...this._animateOptions(t,e));continue}const h=e[l];let c=n[l];const d=i.get(l);if(c){if(d&&c.active()){c.update(d,h,a);continue}c.cancel()}d&&d.duration?(n[l]=c=new Cs(d,t,l,h),s.push(c)):t[l]=h}return s}update(t,e){if(0===this._properties.size)return void Object.assign(t,e);const i=this._createAnimations(t,e);return i.length?(bt.add(this._chart,i),!0):void 0}}function As(t,e){const i=t&&t.options||{},s=i.reverse,n=void 0===i.min?e:0,o=void 0===i.max?e:0;return{start:s?o:n,end:s?n:o}}function Ts(t,e){const i=[],s=t._getSortedDatasetMetas(e);let n,o;for(n=0,o=s.length;n<o;++n)i.push(s[n].index);return i}function Ls(t,e,i,s={}){const n=t.keys,o="single"===s.mode;let r,l,h,c;if(null!==e){for(r=0,l=n.length;r<l;++r){if(h=+n[r],h===i){if(s.all)continue;break}c=t.values[h],a(c)&&(o||0===e||F(e)===F(c))&&(e+=c)}return e}}function Es(t,e){const i=t&&t.options.stacked;return i||void 0===i&&void 0!==e.stack}function Rs(t,e,i){const s=t[e]||(t[e]={});return s[i]||(s[i]={})}function Is(t,e,i,s){for(const n of e.getMatchingVisibleMetas(s).reverse()){const e=t[n.index];if(i&&e>0||!i&&e<0)return n.index}return null}function zs(t,e){const{chart:i,_cachedMeta:s}=t,n=i._stacks||(i._stacks={}),{iScale:o,vScale:a,index:r}=s,l=o.axis,h=a.axis,c=function(t,e,i){return`${t.id}.${e.id}.${i.stack||i.type}`}(o,a,s),d=e.length;let u;for(let t=0;t<d;++t){const i=e[t],{[l]:o,[h]:d}=i;u=(i._stacks||(i._stacks={}))[h]=Rs(n,c,o),u[r]=d,u._top=Is(u,a,!0,s.type),u._bottom=Is(u,a,!1,s.type);(u._visualValues||(u._visualValues={}))[r]=d}}function Fs(t,e){const i=t.scales;return Object.keys(i).filter((t=>i[t].axis===e)).shift()}function Vs(t,e){const i=t.controller.index,s=t.vScale&&t.vScale.axis;if(s){e=e||t._parsed;for(const t of e){const e=t._stacks;if(!e||void 0===e[s]||void 0===e[s][i])return;delete e[s][i],void 0!==e[s]._visualValues&&void 0!==e[s]._visualValues[i]&&delete e[s]._visualValues[i]}}}const Bs=t=>"reset"===t||"none"===t,Ws=(t,e)=>e?t:Object.assign({},t);class Ns{static defaults={};static datasetElementType=null;static dataElementType=null;constructor(t,e){this.chart=t,this._ctx=t.ctx,this.index=e,this._cachedDataOpts={},this._cachedMeta=this.getMeta(),this._type=this._cachedMeta.type,this.options=void 0,this._parsing=!1,this._data=void 0,this._objectData=void 0,this._sharedOptions=void 0,this._drawStart=void 0,this._drawCount=void 0,this.enableOptionSharing=!1,this.supportsDecimation=!1,this.$context=void 0,this._syncList=[],this.datasetElementType=new.target.datasetElementType,this.dataElementType=new.target.dataElementType,this.initialize()}initialize(){const t=this._cachedMeta;this.configure(),this.linkScales(),t._stacked=Es(t.vScale,t),this.addElements(),this.options.fill&&!this.chart.isPluginEnabled("filler")&&console.warn("Tried to use the 'fill' option without the 'Filler' plugin enabled. Please import and register the 'Filler' plugin and make sure it is not disabled in the options")}updateIndex(t){this.index!==t&&Vs(this._cachedMeta),this.index=t}linkScales(){const t=this.chart,e=this._cachedMeta,i=this.getDataset(),s=(t,e,i,s)=>"x"===t?e:"r"===t?s:i,n=e.xAxisID=l(i.xAxisID,Fs(t,"x")),o=e.yAxisID=l(i.yAxisID,Fs(t,"y")),a=e.rAxisID=l(i.rAxisID,Fs(t,"r")),r=e.indexAxis,h=e.iAxisID=s(r,n,o,a),c=e.vAxisID=s(r,o,n,a);e.xScale=this.getScaleForId(n),e.yScale=this.getScaleForId(o),e.rScale=this.getScaleForId(a),e.iScale=this.getScaleForId(h),e.vScale=this.getScaleForId(c)}getDataset(){return this.chart.data.datasets[this.index]}getMeta(){return this.chart.getDatasetMeta(this.index)}getScaleForId(t){return this.chart.scales[t]}_getOtherScale(t){const e=this._cachedMeta;return t===e.iScale?e.vScale:e.iScale}reset(){this._update("reset")}_destroy(){const t=this._cachedMeta;this._data&&rt(this._data,this),t._stacked&&Vs(t)}_dataCheck(){const t=this.getDataset(),e=t.data||(t.data=[]),i=this._data;if(o(e)){const t=this._cachedMeta;this._data=function(t,e){const{iScale:i,vScale:s}=e,n="x"===i.axis?"x":"y",o="x"===s.axis?"x":"y",a=Object.keys(t),r=new Array(a.length);let l,h,c;for(l=0,h=a.length;l<h;++l)c=a[l],r[l]={[n]:c,[o]:t[c]};return r}(e,t)}else if(i!==e){if(i){rt(i,this);const t=this._cachedMeta;Vs(t),t._parsed=[]}e&&Object.isExtensible(e)&&at(e,this),this._syncList=[],this._data=e}}addElements(){const t=this._cachedMeta;this._dataCheck(),this.datasetElementType&&(t.dataset=new this.datasetElementType)}buildOrUpdateElements(t){const e=this._cachedMeta,i=this.getDataset();let s=!1;this._dataCheck();const n=e._stacked;e._stacked=Es(e.vScale,e),e.stack!==i.stack&&(s=!0,Vs(e),e.stack=i.stack),this._resyncElements(t),(s||n!==e._stacked)&&zs(this,e._parsed)}configure(){const t=this.chart.config,e=t.datasetScopeKeys(this._type),i=t.getOptionScopes(this.getDataset(),e,!0);this.options=t.createResolver(i,this.getContext()),this._parsing=this.options.parsing,this._cachedDataOpts={}}parse(t,e){const{_cachedMeta:i,_data:s}=this,{iScale:a,_stacked:r}=i,l=a.axis;let h,c,d,u=0===t&&e===s.length||i._sorted,f=t>0&&i._parsed[t-1];if(!1===this._parsing)i._parsed=s,i._sorted=!0,d=s;else{d=n(s[t])?this.parseArrayData(i,s,t,e):o(s[t])?this.parseObjectData(i,s,t,e):this.parsePrimitiveData(i,s,t,e);const a=()=>null===c[l]||f&&c[l]<f[l];for(h=0;h<e;++h)i._parsed[h+t]=c=d[h],u&&(a()&&(u=!1),f=c);i._sorted=u}r&&zs(this,d)}parsePrimitiveData(t,e,i,s){const{iScale:n,vScale:o}=t,a=n.axis,r=o.axis,l=n.getLabels(),h=n===o,c=new Array(s);let d,u,f;for(d=0,u=s;d<u;++d)f=d+i,c[d]={[a]:h||n.parse(l[f],f),[r]:o.parse(e[f],f)};return c}parseArrayData(t,e,i,s){const{xScale:n,yScale:o}=t,a=new Array(s);let r,l,h,c;for(r=0,l=s;r<l;++r)h=r+i,c=e[h],a[r]={x:n.parse(c[0],h),y:o.parse(c[1],h)};return a}parseObjectData(t,e,i,s){const{xScale:n,yScale:o}=t,{xAxisKey:a="x",yAxisKey:r="y"}=this._parsing,l=new Array(s);let h,c,d,u;for(h=0,c=s;h<c;++h)d=h+i,u=e[d],l[h]={x:n.parse(M(u,a),d),y:o.parse(M(u,r),d)};return l}getParsed(t){return this._cachedMeta._parsed[t]}getDataElement(t){return this._cachedMeta.data[t]}applyStack(t,e,i){const s=this.chart,n=this._cachedMeta,o=e[t.axis];return Ls({keys:Ts(s,!0),values:e._stacks[t.axis]._visualValues},o,n.index,{mode:i})}updateRangeFromParsed(t,e,i,s){const n=i[e.axis];let o=null===n?NaN:n;const a=s&&i._stacks[e.axis];s&&a&&(s.values=a,o=Ls(s,n,this._cachedMeta.index)),t.min=Math.min(t.min,o),t.max=Math.max(t.max,o)}getMinMax(t,e){const i=this._cachedMeta,s=i._parsed,n=i._sorted&&t===i.iScale,o=s.length,r=this._getOtherScale(t),l=((t,e,i)=>t&&!e.hidden&&e._stacked&&{keys:Ts(i,!0),values:null})(e,i,this.chart),h={min:Number.POSITIVE_INFINITY,max:Number.NEGATIVE_INFINITY},{min:c,max:d}=function(t){const{min:e,max:i,minDefined:s,maxDefined:n}=t.getUserBounds();return{min:s?e:Number.NEGATIVE_INFINITY,max:n?i:Number.POSITIVE_INFINITY}}(r);let u,f;function g(){f=s[u];const e=f[r.axis];return!a(f[t.axis])||c>e||d<e}for(u=0;u<o&&(g()||(this.updateRangeFromParsed(h,t,f,l),!n));++u);if(n)for(u=o-1;u>=0;--u)if(!g()){this.updateRangeFromParsed(h,t,f,l);break}return h}getAllParsedValues(t){const e=this._cachedMeta._parsed,i=[];let s,n,o;for(s=0,n=e.length;s<n;++s)o=e[s][t.axis],a(o)&&i.push(o);return i}getMaxOverflow(){return!1}getLabelAndValue(t){const e=this._cachedMeta,i=e.iScale,s=e.vScale,n=this.getParsed(t);return{label:i?""+i.getLabelForValue(n[i.axis]):"",value:s?""+s.getLabelForValue(n[s.axis]):""}}_update(t){const e=this._cachedMeta;this.update(t||"default"),e._clip=function(t){let e,i,s,n;return o(t)?(e=t.top,i=t.right,s=t.bottom,n=t.left):e=i=s=n=t,{top:e,right:i,bottom:s,left:n,disabled:!1===t}}(l(this.options.clip,function(t,e,i){if(!1===i)return!1;const s=As(t,i),n=As(e,i);return{top:n.end,right:s.end,bottom:n.start,left:s.start}}(e.xScale,e.yScale,this.getMaxOverflow())))}update(t){}draw(){const t=this._ctx,e=this.chart,i=this._cachedMeta,s=i.data||[],n=e.chartArea,o=[],a=this._drawStart||0,r=this._drawCount||s.length-a,l=this.options.drawActiveElementsOnTop;let h;for(i.dataset&&i.dataset.draw(t,n,a,r),h=a;h<a+r;++h){const e=s[h];e.hidden||(e.active&&l?o.push(e):e.draw(t,n))}for(h=0;h<o.length;++h)o[h].draw(t,n)}getStyle(t,e){const i=e?"active":"default";return void 0===t&&this._cachedMeta.dataset?this.resolveDatasetElementOptions(i):this.resolveDataElementOptions(t||0,i)}getContext(t,e,i){const s=this.getDataset();let n;if(t>=0&&t<this._cachedMeta.data.length){const e=this._cachedMeta.data[t];n=e.$context||(e.$context=function(t,e,i){return Ci(t,{active:!1,dataIndex:e,parsed:void 0,raw:void 0,element:i,index:e,mode:"default",type:"data"})}(this.getContext(),t,e)),n.parsed=this.getParsed(t),n.raw=s.data[t],n.index=n.dataIndex=t}else n=this.$context||(this.$context=function(t,e){return Ci(t,{active:!1,dataset:void 0,datasetIndex:e,index:e,mode:"default",type:"dataset"})}(this.chart.getContext(),this.index)),n.dataset=s,n.index=n.datasetIndex=this.index;return n.active=!!e,n.mode=i,n}resolveDatasetElementOptions(t){return this._resolveElementOptions(this.datasetElementType.id,t)}resolveDataElementOptions(t,e){return this._resolveElementOptions(this.dataElementType.id,e,t)}_resolveElementOptions(t,e="default",i){const s="active"===e,n=this._cachedDataOpts,o=t+"-"+e,a=n[o],r=this.enableOptionSharing&&k(i);if(a)return Ws(a,r);const l=this.chart.config,h=l.datasetElementScopeKeys(this._type,t),c=s?[`${t}Hover`,"hover",t,""]:[t,""],d=l.getOptionScopes(this.getDataset(),h),u=Object.keys(ue.elements[t]),f=l.resolveNamedOptions(d,u,(()=>this.getContext(i,s,e)),c);return f.$shared&&(f.$shared=r,n[o]=Object.freeze(Ws(f,r))),f}_resolveAnimations(t,e,i){const s=this.chart,n=this._cachedDataOpts,o=`animation-${e}`,a=n[o];if(a)return a;let r;if(!1!==s.options.animation){const s=this.chart.config,n=s.datasetAnimationScopeKeys(this._type,e),o=s.getOptionScopes(this.getDataset(),n);r=s.createResolver(o,this.getContext(t,i,e))}const l=new Os(s,r&&r.animations);return r&&r._cacheable&&(n[o]=Object.freeze(l)),l}getSharedOptions(t){if(t.$shared)return this._sharedOptions||(this._sharedOptions=Object.assign({},t))}includeOptions(t,e){return!e||Bs(t)||this.chart._animationsDisabled}_getSharedOptions(t,e){const i=this.resolveDataElementOptions(t,e),s=this._sharedOptions,n=this.getSharedOptions(i),o=this.includeOptions(e,n)||n!==s;return this.updateSharedOptions(n,e,i),{sharedOptions:n,includeOptions:o}}updateElement(t,e,i,s){Bs(s)?Object.assign(t,i):this._resolveAnimations(e,s).update(t,i)}updateSharedOptions(t,e,i){t&&!Bs(e)&&this._resolveAnimations(void 0,e).update(t,i)}_setStyle(t,e,i,s){t.active=s;const n=this.getStyle(e,s);this._resolveAnimations(e,i,s).update(t,{options:!s&&this.getSharedOptions(n)||n})}removeHoverStyle(t,e,i){this._setStyle(t,i,"active",!1)}setHoverStyle(t,e,i){this._setStyle(t,i,"active",!0)}_removeDatasetHoverStyle(){const t=this._cachedMeta.dataset;t&&this._setStyle(t,void 0,"active",!1)}_setDatasetHoverStyle(){const t=this._cachedMeta.dataset;t&&this._setStyle(t,void 0,"active",!0)}_resyncElements(t){const e=this._data,i=this._cachedMeta.data;for(const[t,e,i]of this._syncList)this[t](e,i);this._syncList=[];const s=i.length,n=e.length,o=Math.min(n,s);o&&this.parse(0,o),n>s?this._insertElements(s,n-s,t):n<s&&this._removeElements(n,s-n)}_insertElements(t,e,i=!0){const s=this._cachedMeta,n=s.data,o=t+e;let a;const r=t=>{for(t.length+=e,a=t.length-1;a>=o;a--)t[a]=t[a-e]};for(r(n),a=t;a<o;++a)n[a]=new this.dataElementType;this._parsing&&r(s._parsed),this.parse(t,e),i&&this.updateElements(n,t,e,"reset")}updateElements(t,e,i,s){}_removeElements(t,e){const i=this._cachedMeta;if(this._parsing){const s=i._parsed.splice(t,e);i._stacked&&Vs(i,s)}i.data.splice(t,e)}_sync(t){if(this._parsing)this._syncList.push(t);else{const[e,i,s]=t;this[e](i,s)}this.chart._dataChanges.push([this.index,...t])}_onDataPush(){const t=arguments.length;this._sync(["_insertElements",this.getDataset().data.length-t,t])}_onDataPop(){this._sync(["_removeElements",this._cachedMeta.data.length-1,1])}_onDataShift(){this._sync(["_removeElements",0,1])}_onDataSplice(t,e){e&&this._sync(["_removeElements",t,e]);const i=arguments.length-2;i&&this._sync(["_insertElements",t,i])}_onDataUnshift(){this._sync(["_insertElements",0,arguments.length])}}class Hs{static defaults={};static defaultRoutes=void 0;x;y;active=!1;options;$animations;tooltipPosition(t){const{x:e,y:i}=this.getProps(["x","y"],t);return{x:e,y:i}}hasValue(){return N(this.x)&&N(this.y)}getProps(t,e){const i=this.$animations;if(!e||!i)return this;const s={};return t.forEach((t=>{s[t]=i[t]&&i[t].active()?i[t]._to:this[t]})),s}}function js(t,e){const i=t.options.ticks,n=function(t){const e=t.options.offset,i=t._tickSize(),s=t._length/i+(e?0:1),n=t._maxLength/i;return Math.floor(Math.min(s,n))}(t),o=Math.min(i.maxTicksLimit||n,n),a=i.major.enabled?function(t){const e=[];let i,s;for(i=0,s=t.length;i<s;i++)t[i].major&&e.push(i);return e}(e):[],r=a.length,l=a[0],h=a[r-1],c=[];if(r>o)return function(t,e,i,s){let n,o=0,a=i[0];for(s=Math.ceil(s),n=0;n<t.length;n++)n===a&&(e.push(t[n]),o++,a=i[o*s])}(e,c,a,r/o),c;const d=function(t,e,i){const s=function(t){const e=t.length;let i,s;if(e<2)return!1;for(s=t[0],i=1;i<e;++i)if(t[i]-t[i-1]!==s)return!1;return s}(t),n=e.length/i;if(!s)return Math.max(n,1);const o=W(s);for(let t=0,e=o.length-1;t<e;t++){const e=o[t];if(e>n)return e}return Math.max(n,1)}(a,e,o);if(r>0){let t,i;const n=r>1?Math.round((h-l)/(r-1)):null;for($s(e,c,d,s(n)?0:l-n,l),t=0,i=r-1;t<i;t++)$s(e,c,d,a[t],a[t+1]);return $s(e,c,d,h,s(n)?e.length:h+n),c}return $s(e,c,d),c}function $s(t,e,i,s,n){const o=l(s,0),a=Math.min(l(n,t.length),t.length);let r,h,c,d=0;for(i=Math.ceil(i),n&&(r=n-s,i=r/Math.floor(r/i)),c=o;c<0;)d++,c=Math.round(o+d*i);for(h=Math.max(o,0);h<a;h++)h===c&&(e.push(t[h]),d++,c=Math.round(o+d*i))}const Ys=(t,e,i)=>"top"===e||"left"===e?t[e]+i:t[e]-i,Us=(t,e)=>Math.min(e||t,t);function Xs(t,e){const i=[],s=t.length/e,n=t.length;let o=0;for(;o<n;o+=s)i.push(t[Math.floor(o)]);return i}function qs(t,e,i){const s=t.ticks.length,n=Math.min(e,s-1),o=t._startPixel,a=t._endPixel,r=1e-6;let l,h=t.getPixelForTick(n);if(!(i&&(l=1===s?Math.max(h-o,a-h):0===e?(t.getPixelForTick(1)-h)/2:(h-t.getPixelForTick(n-1))/2,h+=n<e?l:-l,h<o-r||h>a+r)))return h}function Ks(t){return t.drawTicks?t.tickLength:0}function Gs(t,e){if(!t.display)return 0;const i=Si(t.font,e),s=ki(t.padding);return(n(t.text)?t.text.length:1)*i.lineHeight+s.height}function Zs(t,e,i){let s=ut(t);return(i&&"right"!==e||!i&&"right"===e)&&(s=(t=>"left"===t?"right":"right"===t?"left":t)(s)),s}class Js extends Hs{constructor(t){super(),this.id=t.id,this.type=t.type,this.options=void 0,this.ctx=t.ctx,this.chart=t.chart,this.top=void 0,this.bottom=void 0,this.left=void 0,this.right=void 0,this.width=void 0,this.height=void 0,this._margins={left:0,right:0,top:0,bottom:0},this.maxWidth=void 0,this.maxHeight=void 0,this.paddingTop=void 0,this.paddingBottom=void 0,this.paddingLeft=void 0,this.paddingRight=void 0,this.axis=void 0,this.labelRotation=void 0,this.min=void 0,this.max=void 0,this._range=void 0,this.ticks=[],this._gridLineItems=null,this._labelItems=null,this._labelSizes=null,this._length=0,this._maxLength=0,this._longestTextCache={},this._startPixel=void 0,this._endPixel=void 0,this._reversePixels=!1,this._userMax=void 0,this._userMin=void 0,this._suggestedMax=void 0,this._suggestedMin=void 0,this._ticksLength=0,this._borderValue=0,this._cache={},this._dataLimitsCached=!1,this.$context=void 0}init(t){this.options=t.setContext(this.getContext()),this.axis=t.axis,this._userMin=this.parse(t.min),this._userMax=this.parse(t.max),this._suggestedMin=this.parse(t.suggestedMin),this._suggestedMax=this.parse(t.suggestedMax)}parse(t,e){return t}getUserBounds(){let{_userMin:t,_userMax:e,_suggestedMin:i,_suggestedMax:s}=this;return t=r(t,Number.POSITIVE_INFINITY),e=r(e,Number.NEGATIVE_INFINITY),i=r(i,Number.POSITIVE_INFINITY),s=r(s,Number.NEGATIVE_INFINITY),{min:r(t,i),max:r(e,s),minDefined:a(t),maxDefined:a(e)}}getMinMax(t){let e,{min:i,max:s,minDefined:n,maxDefined:o}=this.getUserBounds();if(n&&o)return{min:i,max:s};const a=this.getMatchingVisibleMetas();for(let r=0,l=a.length;r<l;++r)e=a[r].controller.getMinMax(this,t),n||(i=Math.min(i,e.min)),o||(s=Math.max(s,e.max));return i=o&&i>s?s:i,s=n&&i>s?i:s,{min:r(i,r(s,i)),max:r(s,r(i,s))}}getPadding(){return{left:this.paddingLeft||0,top:this.paddingTop||0,right:this.paddingRight||0,bottom:this.paddingBottom||0}}getTicks(){return this.ticks}getLabels(){const t=this.chart.data;return this.options.labels||(this.isHorizontal()?t.xLabels:t.yLabels)||t.labels||[]}getLabelItems(t=this.chart.chartArea){return this._labelItems||(this._labelItems=this._computeLabelItems(t))}beforeLayout(){this._cache={},this._dataLimitsCached=!1}beforeUpdate(){d(this.options.beforeUpdate,[this])}update(t,e,i){const{beginAtZero:s,grace:n,ticks:o}=this.options,a=o.sampleSize;this.beforeUpdate(),this.maxWidth=t,this.maxHeight=e,this._margins=i=Object.assign({left:0,right:0,top:0,bottom:0},i),this.ticks=null,this._labelSizes=null,this._gridLineItems=null,this._labelItems=null,this.beforeSetDimensions(),this.setDimensions(),this.afterSetDimensions(),this._maxLength=this.isHorizontal()?this.width+i.left+i.right:this.height+i.top+i.bottom,this._dataLimitsCached||(this.beforeDataLimits(),this.determineDataLimits(),this.afterDataLimits(),this._range=Di(this,n,s),this._dataLimitsCached=!0),this.beforeBuildTicks(),this.ticks=this.buildTicks()||[],this.afterBuildTicks();const r=a<this.ticks.length;this._convertTicksToLabels(r?Xs(this.ticks,a):this.ticks),this.configure(),this.beforeCalculateLabelRotation(),this.calculateLabelRotation(),this.afterCalculateLabelRotation(),o.display&&(o.autoSkip||"auto"===o.source)&&(this.ticks=js(this,this.ticks),this._labelSizes=null,this.afterAutoSkip()),r&&this._convertTicksToLabels(this.ticks),this.beforeFit(),this.fit(),this.afterFit(),this.afterUpdate()}configure(){let t,e,i=this.options.reverse;this.isHorizontal()?(t=this.left,e=this.right):(t=this.top,e=this.bottom,i=!i),this._startPixel=t,this._endPixel=e,this._reversePixels=i,this._length=e-t,this._alignToPixels=this.options.alignToPixels}afterUpdate(){d(this.options.afterUpdate,[this])}beforeSetDimensions(){d(this.options.beforeSetDimensions,[this])}setDimensions(){this.isHorizontal()?(this.width=this.maxWidth,this.left=0,this.right=this.width):(this.height=this.maxHeight,this.top=0,this.bottom=this.height),this.paddingLeft=0,this.paddingTop=0,this.paddingRight=0,this.paddingBottom=0}afterSetDimensions(){d(this.options.afterSetDimensions,[this])}_callHooks(t){this.chart.notifyPlugins(t,this.getContext()),d(this.options[t],[this])}beforeDataLimits(){this._callHooks("beforeDataLimits")}determineDataLimits(){}afterDataLimits(){this._callHooks("afterDataLimits")}beforeBuildTicks(){this._callHooks("beforeBuildTicks")}buildTicks(){return[]}afterBuildTicks(){this._callHooks("afterBuildTicks")}beforeTickToLabelConversion(){d(this.options.beforeTickToLabelConversion,[this])}generateTickLabels(t){const e=this.options.ticks;let i,s,n;for(i=0,s=t.length;i<s;i++)n=t[i],n.label=d(e.callback,[n.value,i,t],this)}afterTickToLabelConversion(){d(this.options.afterTickToLabelConversion,[this])}beforeCalculateLabelRotation(){d(this.options.beforeCalculateLabelRotation,[this])}calculateLabelRotation(){const t=this.options,e=t.ticks,i=Us(this.ticks.length,t.ticks.maxTicksLimit),s=e.minRotation||0,n=e.maxRotation;let o,a,r,l=s;if(!this._isVisible()||!e.display||s>=n||i<=1||!this.isHorizontal())return void(this.labelRotation=s);const h=this._getLabelSizes(),c=h.widest.width,d=h.highest.height,u=J(this.chart.width-c,0,this.maxWidth);o=t.offset?this.maxWidth/i:u/(i-1),c+6>o&&(o=u/(i-(t.offset?.5:1)),a=this.maxHeight-Ks(t.grid)-e.padding-Gs(t.title,this.chart.options.font),r=Math.sqrt(c*c+d*d),l=Y(Math.min(Math.asin(J((h.highest.height+6)/o,-1,1)),Math.asin(J(a/r,-1,1))-Math.asin(J(d/r,-1,1)))),l=Math.max(s,Math.min(n,l))),this.labelRotation=l}afterCalculateLabelRotation(){d(this.options.afterCalculateLabelRotation,[this])}afterAutoSkip(){}beforeFit(){d(this.options.beforeFit,[this])}fit(){const t={width:0,height:0},{chart:e,options:{ticks:i,title:s,grid:n}}=this,o=this._isVisible(),a=this.isHorizontal();if(o){const o=Gs(s,e.options.font);if(a?(t.width=this.maxWidth,t.height=Ks(n)+o):(t.height=this.maxHeight,t.width=Ks(n)+o),i.display&&this.ticks.length){const{first:e,last:s,widest:n,highest:o}=this._getLabelSizes(),r=2*i.padding,l=$(this.labelRotation),h=Math.cos(l),c=Math.sin(l);if(a){const e=i.mirror?0:c*n.width+h*o.height;t.height=Math.min(this.maxHeight,t.height+e+r)}else{const e=i.mirror?0:h*n.width+c*o.height;t.width=Math.min(this.maxWidth,t.width+e+r)}this._calculatePadding(e,s,c,h)}}this._handleMargins(),a?(this.width=this._length=e.width-this._margins.left-this._margins.right,this.height=t.height):(this.width=t.width,this.height=this._length=e.height-this._margins.top-this._margins.bottom)}_calculatePadding(t,e,i,s){const{ticks:{align:n,padding:o},position:a}=this.options,r=0!==this.labelRotation,l="top"!==a&&"x"===this.axis;if(this.isHorizontal()){const a=this.getPixelForTick(0)-this.left,h=this.right-this.getPixelForTick(this.ticks.length-1);let c=0,d=0;r?l?(c=s*t.width,d=i*e.height):(c=i*t.height,d=s*e.width):"start"===n?d=e.width:"end"===n?c=t.width:"inner"!==n&&(c=t.width/2,d=e.width/2),this.paddingLeft=Math.max((c-a+o)*this.width/(this.width-a),0),this.paddingRight=Math.max((d-h+o)*this.width/(this.width-h),0)}else{let i=e.height/2,s=t.height/2;"start"===n?(i=0,s=t.height):"end"===n&&(i=e.height,s=0),this.paddingTop=i+o,this.paddingBottom=s+o}}_handleMargins(){this._margins&&(this._margins.left=Math.max(this.paddingLeft,this._margins.left),this._margins.top=Math.max(this.paddingTop,this._margins.top),this._margins.right=Math.max(this.paddingRight,this._margins.right),this._margins.bottom=Math.max(this.paddingBottom,this._margins.bottom))}afterFit(){d(this.options.afterFit,[this])}isHorizontal(){const{axis:t,position:e}=this.options;return"top"===e||"bottom"===e||"x"===t}isFullSize(){return this.options.fullSize}_convertTicksToLabels(t){let e,i;for(this.beforeTickToLabelConversion(),this.generateTickLabels(t),e=0,i=t.length;e<i;e++)s(t[e].label)&&(t.splice(e,1),i--,e--);this.afterTickToLabelConversion()}_getLabelSizes(){let t=this._labelSizes;if(!t){const e=this.options.ticks.sampleSize;let i=this.ticks;e<i.length&&(i=Xs(i,e)),this._labelSizes=t=this._computeLabelSizes(i,i.length,this.options.ticks.maxTicksLimit)}return t}_computeLabelSizes(t,e,i){const{ctx:o,_longestTextCache:a}=this,r=[],l=[],h=Math.floor(e/Us(e,i));let c,d,f,g,p,m,x,b,_,y,v,M=0,w=0;for(c=0;c<e;c+=h){if(g=t[c].label,p=this._resolveTickFontOptions(c),o.font=m=p.string,x=a[m]=a[m]||{data:{},gc:[]},b=p.lineHeight,_=y=0,s(g)||n(g)){if(n(g))for(d=0,f=g.length;d<f;++d)v=g[d],s(v)||n(v)||(_=Ce(o,x.data,x.gc,_,v),y+=b)}else _=Ce(o,x.data,x.gc,_,g),y=b;r.push(_),l.push(y),M=Math.max(_,M),w=Math.max(y,w)}!function(t,e){u(t,(t=>{const i=t.gc,s=i.length/2;let n;if(s>e){for(n=0;n<s;++n)delete t.data[i[n]];i.splice(0,s)}}))}(a,e);const k=r.indexOf(M),S=l.indexOf(w),P=t=>({width:r[t]||0,height:l[t]||0});return{first:P(0),last:P(e-1),widest:P(k),highest:P(S),widths:r,heights:l}}getLabelForValue(t){return t}getPixelForValue(t,e){return NaN}getValueForPixel(t){}getPixelForTick(t){const e=this.ticks;return t<0||t>e.length-1?null:this.getPixelForValue(e[t].value)}getPixelForDecimal(t){this._reversePixels&&(t=1-t);const e=this._startPixel+t*this._length;return Q(this._alignToPixels?Ae(this.chart,e,0):e)}getDecimalForPixel(t){const e=(t-this._startPixel)/this._length;return this._reversePixels?1-e:e}getBasePixel(){return this.getPixelForValue(this.getBaseValue())}getBaseValue(){const{min:t,max:e}=this;return t<0&&e<0?e:t>0&&e>0?t:0}getContext(t){const e=this.ticks||[];if(t>=0&&t<e.length){const i=e[t];return i.$context||(i.$context=function(t,e,i){return Ci(t,{tick:i,index:e,type:"tick"})}(this.getContext(),t,i))}return this.$context||(this.$context=Ci(this.chart.getContext(),{scale:this,type:"scale"}))}_tickSize(){const t=this.options.ticks,e=$(this.labelRotation),i=Math.abs(Math.cos(e)),s=Math.abs(Math.sin(e)),n=this._getLabelSizes(),o=t.autoSkipPadding||0,a=n?n.widest.width+o:0,r=n?n.highest.height+o:0;return this.isHorizontal()?r*i>a*s?a/i:r/s:r*s<a*i?r/i:a/s}_isVisible(){const t=this.options.display;return"auto"!==t?!!t:this.getMatchingVisibleMetas().length>0}_computeGridLineItems(t){const e=this.axis,i=this.chart,s=this.options,{grid:n,position:a,border:r}=s,h=n.offset,c=this.isHorizontal(),d=this.ticks.length+(h?1:0),u=Ks(n),f=[],g=r.setContext(this.getContext()),p=g.display?g.width:0,m=p/2,x=function(t){return Ae(i,t,p)};let b,_,y,v,M,w,k,S,P,D,C,O;if("top"===a)b=x(this.bottom),w=this.bottom-u,S=b-m,D=x(t.top)+m,O=t.bottom;else if("bottom"===a)b=x(this.top),D=t.top,O=x(t.bottom)-m,w=b+m,S=this.top+u;else if("left"===a)b=x(this.right),M=this.right-u,k=b-m,P=x(t.left)+m,C=t.right;else if("right"===a)b=x(this.left),P=t.left,C=x(t.right)-m,M=b+m,k=this.left+u;else if("x"===e){if("center"===a)b=x((t.top+t.bottom)/2+.5);else if(o(a)){const t=Object.keys(a)[0],e=a[t];b=x(this.chart.scales[t].getPixelForValue(e))}D=t.top,O=t.bottom,w=b+m,S=w+u}else if("y"===e){if("center"===a)b=x((t.left+t.right)/2);else if(o(a)){const t=Object.keys(a)[0],e=a[t];b=x(this.chart.scales[t].getPixelForValue(e))}M=b-m,k=M-u,P=t.left,C=t.right}const A=l(s.ticks.maxTicksLimit,d),T=Math.max(1,Math.ceil(d/A));for(_=0;_<d;_+=T){const t=this.getContext(_),e=n.setContext(t),s=r.setContext(t),o=e.lineWidth,a=e.color,l=s.dash||[],d=s.dashOffset,u=e.tickWidth,g=e.tickColor,p=e.tickBorderDash||[],m=e.tickBorderDashOffset;y=qs(this,_,h),void 0!==y&&(v=Ae(i,y,o),c?M=k=P=C=v:w=S=D=O=v,f.push({tx1:M,ty1:w,tx2:k,ty2:S,x1:P,y1:D,x2:C,y2:O,width:o,color:a,borderDash:l,borderDashOffset:d,tickWidth:u,tickColor:g,tickBorderDash:p,tickBorderDashOffset:m}))}return this._ticksLength=d,this._borderValue=b,f}_computeLabelItems(t){const e=this.axis,i=this.options,{position:s,ticks:a}=i,r=this.isHorizontal(),l=this.ticks,{align:h,crossAlign:c,padding:d,mirror:u}=a,f=Ks(i.grid),g=f+d,p=u?-d:g,m=-$(this.labelRotation),x=[];let b,_,y,v,M,w,k,S,P,D,C,O,A="middle";if("top"===s)w=this.bottom-p,k=this._getXAxisLabelAlignment();else if("bottom"===s)w=this.top+p,k=this._getXAxisLabelAlignment();else if("left"===s){const t=this._getYAxisLabelAlignment(f);k=t.textAlign,M=t.x}else if("right"===s){const t=this._getYAxisLabelAlignment(f);k=t.textAlign,M=t.x}else if("x"===e){if("center"===s)w=(t.top+t.bottom)/2+g;else if(o(s)){const t=Object.keys(s)[0],e=s[t];w=this.chart.scales[t].getPixelForValue(e)+g}k=this._getXAxisLabelAlignment()}else if("y"===e){if("center"===s)M=(t.left+t.right)/2-g;else if(o(s)){const t=Object.keys(s)[0],e=s[t];M=this.chart.scales[t].getPixelForValue(e)}k=this._getYAxisLabelAlignment(f).textAlign}"y"===e&&("start"===h?A="top":"end"===h&&(A="bottom"));const T=this._getLabelSizes();for(b=0,_=l.length;b<_;++b){y=l[b],v=y.label;const t=a.setContext(this.getContext(b));S=this.getPixelForTick(b)+a.labelOffset,P=this._resolveTickFontOptions(b),D=P.lineHeight,C=n(v)?v.length:1;const e=C/2,i=t.color,o=t.textStrokeColor,h=t.textStrokeWidth;let d,f=k;if(r?(M=S,"inner"===k&&(f=b===_-1?this.options.reverse?"left":"right":0===b?this.options.reverse?"right":"left":"center"),O="top"===s?"near"===c||0!==m?-C*D+D/2:"center"===c?-T.highest.height/2-e*D+D:-T.highest.height+D/2:"near"===c||0!==m?D/2:"center"===c?T.highest.height/2-e*D:T.highest.height-C*D,u&&(O*=-1),0===m||t.showLabelBackdrop||(M+=D/2*Math.sin(m))):(w=S,O=(1-C)*D/2),t.showLabelBackdrop){const e=ki(t.backdropPadding),i=T.heights[b],s=T.widths[b];let n=O-e.top,o=0-e.left;switch(A){case"middle":n-=i/2;break;case"bottom":n-=i}switch(k){case"center":o-=s/2;break;case"right":o-=s;break;case"inner":b===_-1?o-=s:b>0&&(o-=s/2)}d={left:o,top:n,width:s+e.width,height:i+e.height,color:t.backdropColor}}x.push({label:v,font:P,textOffset:O,options:{rotation:m,color:i,strokeColor:o,strokeWidth:h,textAlign:f,textBaseline:A,translation:[M,w],backdrop:d}})}return x}_getXAxisLabelAlignment(){const{position:t,ticks:e}=this.options;if(-$(this.labelRotation))return"top"===t?"left":"right";let i="center";return"start"===e.align?i="left":"end"===e.align?i="right":"inner"===e.align&&(i="inner"),i}_getYAxisLabelAlignment(t){const{position:e,ticks:{crossAlign:i,mirror:s,padding:n}}=this.options,o=t+n,a=this._getLabelSizes().widest.width;let r,l;return"left"===e?s?(l=this.right+n,"near"===i?r="left":"center"===i?(r="center",l+=a/2):(r="right",l+=a)):(l=this.right-o,"near"===i?r="right":"center"===i?(r="center",l-=a/2):(r="left",l=this.left)):"right"===e?s?(l=this.left+n,"near"===i?r="right":"center"===i?(r="center",l-=a/2):(r="left",l-=a)):(l=this.left+o,"near"===i?r="left":"center"===i?(r="center",l+=a/2):(r="right",l=this.right)):r="right",{textAlign:r,x:l}}_computeLabelArea(){if(this.options.ticks.mirror)return;const t=this.chart,e=this.options.position;return"left"===e||"right"===e?{top:0,left:this.left,bottom:t.height,right:this.right}:"top"===e||"bottom"===e?{top:this.top,left:0,bottom:this.bottom,right:t.width}:void 0}drawBackground(){const{ctx:t,options:{backgroundColor:e},left:i,top:s,width:n,height:o}=this;e&&(t.save(),t.fillStyle=e,t.fillRect(i,s,n,o),t.restore())}getLineWidthForValue(t){const e=this.options.grid;if(!this._isVisible()||!e.display)return 0;const i=this.ticks.findIndex((e=>e.value===t));if(i>=0){return e.setContext(this.getContext(i)).lineWidth}return 0}drawGrid(t){const e=this.options.grid,i=this.ctx,s=this._gridLineItems||(this._gridLineItems=this._computeGridLineItems(t));let n,o;const a=(t,e,s)=>{s.width&&s.color&&(i.save(),i.lineWidth=s.width,i.strokeStyle=s.color,i.setLineDash(s.borderDash||[]),i.lineDashOffset=s.borderDashOffset,i.beginPath(),i.moveTo(t.x,t.y),i.lineTo(e.x,e.y),i.stroke(),i.restore())};if(e.display)for(n=0,o=s.length;n<o;++n){const t=s[n];e.drawOnChartArea&&a({x:t.x1,y:t.y1},{x:t.x2,y:t.y2},t),e.drawTicks&&a({x:t.tx1,y:t.ty1},{x:t.tx2,y:t.ty2},{color:t.tickColor,width:t.tickWidth,borderDash:t.tickBorderDash,borderDashOffset:t.tickBorderDashOffset})}}drawBorder(){const{chart:t,ctx:e,options:{border:i,grid:s}}=this,n=i.setContext(this.getContext()),o=i.display?n.width:0;if(!o)return;const a=s.setContext(this.getContext(0)).lineWidth,r=this._borderValue;let l,h,c,d;this.isHorizontal()?(l=Ae(t,this.left,o)-o/2,h=Ae(t,this.right,a)+a/2,c=d=r):(c=Ae(t,this.top,o)-o/2,d=Ae(t,this.bottom,a)+a/2,l=h=r),e.save(),e.lineWidth=n.width,e.strokeStyle=n.color,e.beginPath(),e.moveTo(l,c),e.lineTo(h,d),e.stroke(),e.restore()}drawLabels(t){if(!this.options.ticks.display)return;const e=this.ctx,i=this._computeLabelArea();i&&Ie(e,i);const s=this.getLabelItems(t);for(const t of s){const i=t.options,s=t.font;Ne(e,t.label,0,t.textOffset,s,i)}i&&ze(e)}drawTitle(){const{ctx:t,options:{position:e,title:i,reverse:s}}=this;if(!i.display)return;const a=Si(i.font),r=ki(i.padding),l=i.align;let h=a.lineHeight/2;"bottom"===e||"center"===e||o(e)?(h+=r.bottom,n(i.text)&&(h+=a.lineHeight*(i.text.length-1))):h+=r.top;const{titleX:c,titleY:d,maxWidth:u,rotation:f}=function(t,e,i,s){const{top:n,left:a,bottom:r,right:l,chart:h}=t,{chartArea:c,scales:d}=h;let u,f,g,p=0;const m=r-n,x=l-a;if(t.isHorizontal()){if(f=ft(s,a,l),o(i)){const t=Object.keys(i)[0],s=i[t];g=d[t].getPixelForValue(s)+m-e}else g="center"===i?(c.bottom+c.top)/2+m-e:Ys(t,i,e);u=l-a}else{if(o(i)){const t=Object.keys(i)[0],s=i[t];f=d[t].getPixelForValue(s)-x+e}else f="center"===i?(c.left+c.right)/2-x+e:Ys(t,i,e);g=ft(s,r,n),p="left"===i?-E:E}return{titleX:f,titleY:g,maxWidth:u,rotation:p}}(this,h,e,l);Ne(t,i.text,0,0,a,{color:i.color,maxWidth:u,rotation:f,textAlign:Zs(l,e,s),textBaseline:"middle",translation:[c,d]})}draw(t){this._isVisible()&&(this.drawBackground(),this.drawGrid(t),this.drawBorder(),this.drawTitle(),this.drawLabels(t))}_layers(){const t=this.options,e=t.ticks&&t.ticks.z||0,i=l(t.grid&&t.grid.z,-1),s=l(t.border&&t.border.z,0);return this._isVisible()&&this.draw===Js.prototype.draw?[{z:i,draw:t=>{this.drawBackground(),this.drawGrid(t),this.drawTitle()}},{z:s,draw:()=>{this.drawBorder()}},{z:e,draw:t=>{this.drawLabels(t)}}]:[{z:e,draw:t=>{this.draw(t)}}]}getMatchingVisibleMetas(t){const e=this.chart.getSortedVisibleDatasetMetas(),i=this.axis+"AxisID",s=[];let n,o;for(n=0,o=e.length;n<o;++n){const o=e[n];o[i]!==this.id||t&&o.type!==t||s.push(o)}return s}_resolveTickFontOptions(t){return Si(this.options.ticks.setContext(this.getContext(t)).font)}_maxDigits(){const t=this._resolveTickFontOptions(0).lineHeight;return(this.isHorizontal()?this.width:this.height)/t}}class Qs{constructor(t,e,i){this.type=t,this.scope=e,this.override=i,this.items=Object.create(null)}isForType(t){return Object.prototype.isPrototypeOf.call(this.type.prototype,t.prototype)}register(t){const e=Object.getPrototypeOf(t);let i;(function(t){return"id"in t&&"defaults"in t})(e)&&(i=this.register(e));const s=this.items,n=t.id,o=this.scope+"."+n;if(!n)throw new Error("class does not have id: "+t);return n in s||(s[n]=t,function(t,e,i){const s=x(Object.create(null),[i?ue.get(i):{},ue.get(e),t.defaults]);ue.set(e,s),t.defaultRoutes&&function(t,e){Object.keys(e).forEach((i=>{const s=i.split("."),n=s.pop(),o=[t].concat(s).join("."),a=e[i].split("."),r=a.pop(),l=a.join(".");ue.route(o,n,l,r)}))}(e,t.defaultRoutes);t.descriptors&&ue.describe(e,t.descriptors)}(t,o,i),this.override&&ue.override(t.id,t.overrides)),o}get(t){return this.items[t]}unregister(t){const e=this.items,i=t.id,s=this.scope;i in e&&delete e[i],s&&i in ue[s]&&(delete ue[s][i],this.override&&delete re[i])}}class tn{constructor(){this.controllers=new Qs(Ns,"datasets",!0),this.elements=new Qs(Hs,"elements"),this.plugins=new Qs(Object,"plugins"),this.scales=new Qs(Js,"scales"),this._typedRegistries=[this.controllers,this.scales,this.elements]}add(...t){this._each("register",t)}remove(...t){this._each("unregister",t)}addControllers(...t){this._each("register",t,this.controllers)}addElements(...t){this._each("register",t,this.elements)}addPlugins(...t){this._each("register",t,this.plugins)}addScales(...t){this._each("register",t,this.scales)}getController(t){return this._get(t,this.controllers,"controller")}getElement(t){return this._get(t,this.elements,"element")}getPlugin(t){return this._get(t,this.plugins,"plugin")}getScale(t){return this._get(t,this.scales,"scale")}removeControllers(...t){this._each("unregister",t,this.controllers)}removeElements(...t){this._each("unregister",t,this.elements)}removePlugins(...t){this._each("unregister",t,this.plugins)}removeScales(...t){this._each("unregister",t,this.scales)}_each(t,e,i){[...e].forEach((e=>{const s=i||this._getRegistryForType(e);i||s.isForType(e)||s===this.plugins&&e.id?this._exec(t,s,e):u(e,(e=>{const s=i||this._getRegistryForType(e);this._exec(t,s,e)}))}))}_exec(t,e,i){const s=w(t);d(i["before"+s],[],i),e[t](i),d(i["after"+s],[],i)}_getRegistryForType(t){for(let e=0;e<this._typedRegistries.length;e++){const i=this._typedRegistries[e];if(i.isForType(t))return i}return this.plugins}_get(t,e,i){const s=e.get(t);if(void 0===s)throw new Error('"'+t+'" is not a registered '+i+".");return s}}var en=new tn;class sn{constructor(){this._init=[]}notify(t,e,i,s){"beforeInit"===e&&(this._init=this._createDescriptors(t,!0),this._notify(this._init,t,"install"));const n=s?this._descriptors(t).filter(s):this._descriptors(t),o=this._notify(n,t,e,i);return"afterDestroy"===e&&(this._notify(n,t,"stop"),this._notify(this._init,t,"uninstall")),o}_notify(t,e,i,s){s=s||{};for(const n of t){const t=n.plugin;if(!1===d(t[i],[e,s,n.options],t)&&s.cancelable)return!1}return!0}invalidate(){s(this._cache)||(this._oldCache=this._cache,this._cache=void 0)}_descriptors(t){if(this._cache)return this._cache;const e=this._cache=this._createDescriptors(t);return this._notifyStateChanges(t),e}_createDescriptors(t,e){const i=t&&t.config,s=l(i.options&&i.options.plugins,{}),n=function(t){const e={},i=[],s=Object.keys(en.plugins.items);for(let t=0;t<s.length;t++)i.push(en.getPlugin(s[t]));const n=t.plugins||[];for(let t=0;t<n.length;t++){const s=n[t];-1===i.indexOf(s)&&(i.push(s),e[s.id]=!0)}return{plugins:i,localIds:e}}(i);return!1!==s||e?function(t,{plugins:e,localIds:i},s,n){const o=[],a=t.getContext();for(const r of e){const e=r.id,l=nn(s[e],n);null!==l&&o.push({plugin:r,options:on(t.config,{plugin:r,local:i[e]},l,a)})}return o}(t,n,s,e):[]}_notifyStateChanges(t){const e=this._oldCache||[],i=this._cache,s=(t,e)=>t.filter((t=>!e.some((e=>t.plugin.id===e.plugin.id))));this._notify(s(e,i),t,"stop"),this._notify(s(i,e),t,"start")}}function nn(t,e){return e||!1!==t?!0===t?{}:t:null}function on(t,{plugin:e,local:i},s,n){const o=t.pluginScopeKeys(e),a=t.getOptionScopes(s,o);return i&&e.defaults&&a.push(e.defaults),t.createResolver(a,n,[""],{scriptable:!1,indexable:!1,allKeys:!0})}function an(t,e){const i=ue.datasets[t]||{};return((e.datasets||{})[t]||{}).indexAxis||e.indexAxis||i.indexAxis||"x"}function rn(t){if("x"===t||"y"===t||"r"===t)return t}function ln(t,...e){if(rn(t))return t;for(const s of e){const e=s.axis||("top"===(i=s.position)||"bottom"===i?"x":"left"===i||"right"===i?"y":void 0)||t.length>1&&rn(t[0].toLowerCase());if(e)return e}var i;throw new Error(`Cannot determine type of '${t}' axis. Please provide 'axis' or 'position' option.`)}function hn(t,e,i){if(i[e+"AxisID"]===t)return{axis:e}}function cn(t,e){const i=re[t.type]||{scales:{}},s=e.scales||{},n=an(t.type,e),a=Object.create(null);return Object.keys(s).forEach((e=>{const r=s[e];if(!o(r))return console.error(`Invalid scale configuration for scale: ${e}`);if(r._proxy)return console.warn(`Ignoring resolver passed as options for scale: ${e}`);const l=ln(e,r,function(t,e){if(e.data&&e.data.datasets){const i=e.data.datasets.filter((e=>e.xAxisID===t||e.yAxisID===t));if(i.length)return hn(t,"x",i[0])||hn(t,"y",i[0])}return{}}(e,t),ue.scales[r.type]),h=function(t,e){return t===e?"_index_":"_value_"}(l,n),c=i.scales||{};a[e]=b(Object.create(null),[{axis:l},r,c[l],c[h]])})),t.data.datasets.forEach((i=>{const n=i.type||t.type,o=i.indexAxis||an(n,e),r=(re[n]||{}).scales||{};Object.keys(r).forEach((t=>{const e=function(t,e){let i=t;return"_index_"===t?i=e:"_value_"===t&&(i="x"===e?"y":"x"),i}(t,o),n=i[e+"AxisID"]||e;a[n]=a[n]||Object.create(null),b(a[n],[{axis:e},s[n],r[t]])}))})),Object.keys(a).forEach((t=>{const e=a[t];b(e,[ue.scales[e.type],ue.scale])})),a}function dn(t){const e=t.options||(t.options={});e.plugins=l(e.plugins,{}),e.scales=cn(t,e)}function un(t){return(t=t||{}).datasets=t.datasets||[],t.labels=t.labels||[],t}const fn=new Map,gn=new Set;function pn(t,e){let i=fn.get(t);return i||(i=e(),fn.set(t,i),gn.add(i)),i}const mn=(t,e,i)=>{const s=M(e,i);void 0!==s&&t.add(s)};class xn{constructor(t){this._config=function(t){return(t=t||{}).data=un(t.data),dn(t),t}(t),this._scopeCache=new Map,this._resolverCache=new Map}get platform(){return this._config.platform}get type(){return this._config.type}set type(t){this._config.type=t}get data(){return this._config.data}set data(t){this._config.data=un(t)}get options(){return this._config.options}set options(t){this._config.options=t}get plugins(){return this._config.plugins}update(){const t=this._config;this.clearCache(),dn(t)}clearCache(){this._scopeCache.clear(),this._resolverCache.clear()}datasetScopeKeys(t){return pn(t,(()=>[[`datasets.${t}`,""]]))}datasetAnimationScopeKeys(t,e){return pn(`${t}.transition.${e}`,(()=>[[`datasets.${t}.transitions.${e}`,`transitions.${e}`],[`datasets.${t}`,""]]))}datasetElementScopeKeys(t,e){return pn(`${t}-${e}`,(()=>[[`datasets.${t}.elements.${e}`,`datasets.${t}`,`elements.${e}`,""]]))}pluginScopeKeys(t){const e=t.id;return pn(`${this.type}-plugin-${e}`,(()=>[[`plugins.${e}`,...t.additionalOptionScopes||[]]]))}_cachedScopes(t,e){const i=this._scopeCache;let s=i.get(t);return s&&!e||(s=new Map,i.set(t,s)),s}getOptionScopes(t,e,i){const{options:s,type:n}=this,o=this._cachedScopes(t,i),a=o.get(e);if(a)return a;const r=new Set;e.forEach((e=>{t&&(r.add(t),e.forEach((e=>mn(r,t,e)))),e.forEach((t=>mn(r,s,t))),e.forEach((t=>mn(r,re[n]||{},t))),e.forEach((t=>mn(r,ue,t))),e.forEach((t=>mn(r,le,t)))}));const l=Array.from(r);return 0===l.length&&l.push(Object.create(null)),gn.has(e)&&o.set(e,l),l}chartOptionScopes(){const{options:t,type:e}=this;return[t,re[e]||{},ue.datasets[e]||{},{type:e},ue,le]}resolveNamedOptions(t,e,i,s=[""]){const o={$shared:!0},{resolver:a,subPrefixes:r}=bn(this._resolverCache,t,s);let l=a;if(function(t,e){const{isScriptable:i,isIndexable:s}=Ye(t);for(const o of e){const e=i(o),a=s(o),r=(a||e)&&t[o];if(e&&(S(r)||_n(r))||a&&n(r))return!0}return!1}(a,e)){o.$shared=!1;l=$e(a,i=S(i)?i():i,this.createResolver(t,i,r))}for(const t of e)o[t]=l[t];return o}createResolver(t,e,i=[""],s){const{resolver:n}=bn(this._resolverCache,t,i);return o(e)?$e(n,e,void 0,s):n}}function bn(t,e,i){let s=t.get(e);s||(s=new Map,t.set(e,s));const n=i.join();let o=s.get(n);if(!o){o={resolver:je(e,i),subPrefixes:i.filter((t=>!t.toLowerCase().includes("hover")))},s.set(n,o)}return o}const _n=t=>o(t)&&Object.getOwnPropertyNames(t).some((e=>S(t[e])));const yn=["top","bottom","left","right","chartArea"];function vn(t,e){return"top"===t||"bottom"===t||-1===yn.indexOf(t)&&"x"===e}function Mn(t,e){return function(i,s){return i[t]===s[t]?i[e]-s[e]:i[t]-s[t]}}function wn(t){const e=t.chart,i=e.options.animation;e.notifyPlugins("afterRender"),d(i&&i.onComplete,[t],e)}function kn(t){const e=t.chart,i=e.options.animation;d(i&&i.onProgress,[t],e)}function Sn(t){return fe()&&"string"==typeof t?t=document.getElementById(t):t&&t.length&&(t=t[0]),t&&t.canvas&&(t=t.canvas),t}const Pn={},Dn=t=>{const e=Sn(t);return Object.values(Pn).filter((t=>t.canvas===e)).pop()};function Cn(t,e,i){const s=Object.keys(t);for(const n of s){const s=+n;if(s>=e){const o=t[n];delete t[n],(i>0||s>e)&&(t[s+i]=o)}}}function On(t,e,i){return t.options.clip?t[i]:e[i]}class An{static defaults=ue;static instances=Pn;static overrides=re;static registry=en;static version="4.4.4";static getChart=Dn;static register(...t){en.add(...t),Tn()}static unregister(...t){en.remove(...t),Tn()}constructor(t,e){const s=this.config=new xn(e),n=Sn(t),o=Dn(n);if(o)throw new Error("Canvas is already in use. Chart with ID '"+o.id+"' must be destroyed before the canvas with ID '"+o.canvas.id+"' can be reused.");const a=s.createResolver(s.chartOptionScopes(),this.getContext());this.platform=new(s.platform||ks(n)),this.platform.updateConfig(s);const r=this.platform.acquireContext(n,a.aspectRatio),l=r&&r.canvas,h=l&&l.height,c=l&&l.width;this.id=i(),this.ctx=r,this.canvas=l,this.width=c,this.height=h,this._options=a,this._aspectRatio=this.aspectRatio,this._layers=[],this._metasets=[],this._stacks=void 0,this.boxes=[],this.currentDevicePixelRatio=void 0,this.chartArea=void 0,this._active=[],this._lastEvent=void 0,this._listeners={},this._responsiveListeners=void 0,this._sortedMetasets=[],this.scales={},this._plugins=new sn,this.$proxies={},this._hiddenIndices={},this.attached=!1,this._animationsDisabled=void 0,this.$context=void 0,this._doResize=dt((t=>this.update(t)),a.resizeDelay||0),this._dataChanges=[],Pn[this.id]=this,r&&l?(bt.listen(this,"complete",wn),bt.listen(this,"progress",kn),this._initialize(),this.attached&&this.update()):console.error("Failed to create chart: can't acquire context from the given item")}get aspectRatio(){const{options:{aspectRatio:t,maintainAspectRatio:e},width:i,height:n,_aspectRatio:o}=this;return s(t)?e&&o?o:n?i/n:null:t}get data(){return this.config.data}set data(t){this.config.data=t}get options(){return this._options}set options(t){this.config.options=t}get registry(){return en}_initialize(){return this.notifyPlugins("beforeInit"),this.options.responsive?this.resize():ke(this,this.options.devicePixelRatio),this.bindEvents(),this.notifyPlugins("afterInit"),this}clear(){return Te(this.canvas,this.ctx),this}stop(){return bt.stop(this),this}resize(t,e){bt.running(this)?this._resizeBeforeDraw={width:t,height:e}:this._resize(t,e)}_resize(t,e){const i=this.options,s=this.canvas,n=i.maintainAspectRatio&&this.aspectRatio,o=this.platform.getMaximumSize(s,t,e,n),a=i.devicePixelRatio||this.platform.getDevicePixelRatio(),r=this.width?"resize":"attach";this.width=o.width,this.height=o.height,this._aspectRatio=this.aspectRatio,ke(this,a,!0)&&(this.notifyPlugins("resize",{size:o}),d(i.onResize,[this,o],this),this.attached&&this._doResize(r)&&this.render())}ensureScalesHaveIDs(){u(this.options.scales||{},((t,e)=>{t.id=e}))}buildOrUpdateScales(){const t=this.options,e=t.scales,i=this.scales,s=Object.keys(i).reduce(((t,e)=>(t[e]=!1,t)),{});let n=[];e&&(n=n.concat(Object.keys(e).map((t=>{const i=e[t],s=ln(t,i),n="r"===s,o="x"===s;return{options:i,dposition:n?"chartArea":o?"bottom":"left",dtype:n?"radialLinear":o?"category":"linear"}})))),u(n,(e=>{const n=e.options,o=n.id,a=ln(o,n),r=l(n.type,e.dtype);void 0!==n.position&&vn(n.position,a)===vn(e.dposition)||(n.position=e.dposition),s[o]=!0;let h=null;if(o in i&&i[o].type===r)h=i[o];else{h=new(en.getScale(r))({id:o,type:r,ctx:this.ctx,chart:this}),i[h.id]=h}h.init(n,t)})),u(s,((t,e)=>{t||delete i[e]})),u(i,(t=>{as.configure(this,t,t.options),as.addBox(this,t)}))}_updateMetasets(){const t=this._metasets,e=this.data.datasets.length,i=t.length;if(t.sort(((t,e)=>t.index-e.index)),i>e){for(let t=e;t<i;++t)this._destroyDatasetMeta(t);t.splice(e,i-e)}this._sortedMetasets=t.slice(0).sort(Mn("order","index"))}_removeUnreferencedMetasets(){const{_metasets:t,data:{datasets:e}}=this;t.length>e.length&&delete this._stacks,t.forEach(((t,i)=>{0===e.filter((e=>e===t._dataset)).length&&this._destroyDatasetMeta(i)}))}buildOrUpdateControllers(){const t=[],e=this.data.datasets;let i,s;for(this._removeUnreferencedMetasets(),i=0,s=e.length;i<s;i++){const s=e[i];let n=this.getDatasetMeta(i);const o=s.type||this.config.type;if(n.type&&n.type!==o&&(this._destroyDatasetMeta(i),n=this.getDatasetMeta(i)),n.type=o,n.indexAxis=s.indexAxis||an(o,this.options),n.order=s.order||0,n.index=i,n.label=""+s.label,n.visible=this.isDatasetVisible(i),n.controller)n.controller.updateIndex(i),n.controller.linkScales();else{const e=en.getController(o),{datasetElementType:s,dataElementType:a}=ue.datasets[o];Object.assign(e,{dataElementType:en.getElement(a),datasetElementType:s&&en.getElement(s)}),n.controller=new e(this,i),t.push(n.controller)}}return this._updateMetasets(),t}_resetElements(){u(this.data.datasets,((t,e)=>{this.getDatasetMeta(e).controller.reset()}),this)}reset(){this._resetElements(),this.notifyPlugins("reset")}update(t){const e=this.config;e.update();const i=this._options=e.createResolver(e.chartOptionScopes(),this.getContext()),s=this._animationsDisabled=!i.animation;if(this._updateScales(),this._checkEventBindings(),this._updateHiddenIndices(),this._plugins.invalidate(),!1===this.notifyPlugins("beforeUpdate",{mode:t,cancelable:!0}))return;const n=this.buildOrUpdateControllers();this.notifyPlugins("beforeElementsUpdate");let o=0;for(let t=0,e=this.data.datasets.length;t<e;t++){const{controller:e}=this.getDatasetMeta(t),i=!s&&-1===n.indexOf(e);e.buildOrUpdateElements(i),o=Math.max(+e.getMaxOverflow(),o)}o=this._minPadding=i.layout.autoPadding?o:0,this._updateLayout(o),s||u(n,(t=>{t.reset()})),this._updateDatasets(t),this.notifyPlugins("afterUpdate",{mode:t}),this._layers.sort(Mn("z","_idx"));const{_active:a,_lastEvent:r}=this;r?this._eventHandler(r,!0):a.length&&this._updateHoverStyles(a,a,!0),this.render()}_updateScales(){u(this.scales,(t=>{as.removeBox(this,t)})),this.ensureScalesHaveIDs(),this.buildOrUpdateScales()}_checkEventBindings(){const t=this.options,e=new Set(Object.keys(this._listeners)),i=new Set(t.events);P(e,i)&&!!this._responsiveListeners===t.responsive||(this.unbindEvents(),this.bindEvents())}_updateHiddenIndices(){const{_hiddenIndices:t}=this,e=this._getUniformDataChanges()||[];for(const{method:i,start:s,count:n}of e){Cn(t,s,"_removeElements"===i?-n:n)}}_getUniformDataChanges(){const t=this._dataChanges;if(!t||!t.length)return;this._dataChanges=[];const e=this.data.datasets.length,i=e=>new Set(t.filter((t=>t[0]===e)).map(((t,e)=>e+","+t.splice(1).join(",")))),s=i(0);for(let t=1;t<e;t++)if(!P(s,i(t)))return;return Array.from(s).map((t=>t.split(","))).map((t=>({method:t[1],start:+t[2],count:+t[3]})))}_updateLayout(t){if(!1===this.notifyPlugins("beforeLayout",{cancelable:!0}))return;as.update(this,this.width,this.height,t);const e=this.chartArea,i=e.width<=0||e.height<=0;this._layers=[],u(this.boxes,(t=>{i&&"chartArea"===t.position||(t.configure&&t.configure(),this._layers.push(...t._layers()))}),this),this._layers.forEach(((t,e)=>{t._idx=e})),this.notifyPlugins("afterLayout")}_updateDatasets(t){if(!1!==this.notifyPlugins("beforeDatasetsUpdate",{mode:t,cancelable:!0})){for(let t=0,e=this.data.datasets.length;t<e;++t)this.getDatasetMeta(t).controller.configure();for(let e=0,i=this.data.datasets.length;e<i;++e)this._updateDataset(e,S(t)?t({datasetIndex:e}):t);this.notifyPlugins("afterDatasetsUpdate",{mode:t})}}_updateDataset(t,e){const i=this.getDatasetMeta(t),s={meta:i,index:t,mode:e,cancelable:!0};!1!==this.notifyPlugins("beforeDatasetUpdate",s)&&(i.controller._update(e),s.cancelable=!1,this.notifyPlugins("afterDatasetUpdate",s))}render(){!1!==this.notifyPlugins("beforeRender",{cancelable:!0})&&(bt.has(this)?this.attached&&!bt.running(this)&&bt.start(this):(this.draw(),wn({chart:this})))}draw(){let t;if(this._resizeBeforeDraw){const{width:t,height:e}=this._resizeBeforeDraw;this._resizeBeforeDraw=null,this._resize(t,e)}if(this.clear(),this.width<=0||this.height<=0)return;if(!1===this.notifyPlugins("beforeDraw",{cancelable:!0}))return;const e=this._layers;for(t=0;t<e.length&&e[t].z<=0;++t)e[t].draw(this.chartArea);for(this._drawDatasets();t<e.length;++t)e[t].draw(this.chartArea);this.notifyPlugins("afterDraw")}_getSortedDatasetMetas(t){const e=this._sortedMetasets,i=[];let s,n;for(s=0,n=e.length;s<n;++s){const n=e[s];t&&!n.visible||i.push(n)}return i}getSortedVisibleDatasetMetas(){return this._getSortedDatasetMetas(!0)}_drawDatasets(){if(!1===this.notifyPlugins("beforeDatasetsDraw",{cancelable:!0}))return;const t=this.getSortedVisibleDatasetMetas();for(let e=t.length-1;e>=0;--e)this._drawDataset(t[e]);this.notifyPlugins("afterDatasetsDraw")}_drawDataset(t){const e=this.ctx,i=t._clip,s=!i.disabled,n=function(t,e){const{xScale:i,yScale:s}=t;return i&&s?{left:On(i,e,"left"),right:On(i,e,"right"),top:On(s,e,"top"),bottom:On(s,e,"bottom")}:e}(t,this.chartArea),o={meta:t,index:t.index,cancelable:!0};!1!==this.notifyPlugins("beforeDatasetDraw",o)&&(s&&Ie(e,{left:!1===i.left?0:n.left-i.left,right:!1===i.right?this.width:n.right+i.right,top:!1===i.top?0:n.top-i.top,bottom:!1===i.bottom?this.height:n.bottom+i.bottom}),t.controller.draw(),s&&ze(e),o.cancelable=!1,this.notifyPlugins("afterDatasetDraw",o))}isPointInArea(t){return Re(t,this.chartArea,this._minPadding)}getElementsAtEventForMode(t,e,i,s){const n=Xi.modes[e];return"function"==typeof n?n(this,t,i,s):[]}getDatasetMeta(t){const e=this.data.datasets[t],i=this._metasets;let s=i.filter((t=>t&&t._dataset===e)).pop();return s||(s={type:null,data:[],dataset:null,controller:null,hidden:null,xAxisID:null,yAxisID:null,order:e&&e.order||0,index:t,_dataset:e,_parsed:[],_sorted:!1},i.push(s)),s}getContext(){return this.$context||(this.$context=Ci(null,{chart:this,type:"chart"}))}getVisibleDatasetCount(){return this.getSortedVisibleDatasetMetas().length}isDatasetVisible(t){const e=this.data.datasets[t];if(!e)return!1;const i=this.getDatasetMeta(t);return"boolean"==typeof i.hidden?!i.hidden:!e.hidden}setDatasetVisibility(t,e){this.getDatasetMeta(t).hidden=!e}toggleDataVisibility(t){this._hiddenIndices[t]=!this._hiddenIndices[t]}getDataVisibility(t){return!this._hiddenIndices[t]}_updateVisibility(t,e,i){const s=i?"show":"hide",n=this.getDatasetMeta(t),o=n.controller._resolveAnimations(void 0,s);k(e)?(n.data[e].hidden=!i,this.update()):(this.setDatasetVisibility(t,i),o.update(n,{visible:i}),this.update((e=>e.datasetIndex===t?s:void 0)))}hide(t,e){this._updateVisibility(t,e,!1)}show(t,e){this._updateVisibility(t,e,!0)}_destroyDatasetMeta(t){const e=this._metasets[t];e&&e.controller&&e.controller._destroy(),delete this._metasets[t]}_stop(){let t,e;for(this.stop(),bt.remove(this),t=0,e=this.data.datasets.length;t<e;++t)this._destroyDatasetMeta(t)}destroy(){this.notifyPlugins("beforeDestroy");const{canvas:t,ctx:e}=this;this._stop(),this.config.clearCache(),t&&(this.unbindEvents(),Te(t,e),this.platform.releaseContext(e),this.canvas=null,this.ctx=null),delete Pn[this.id],this.notifyPlugins("afterDestroy")}toBase64Image(...t){return this.canvas.toDataURL(...t)}bindEvents(){this.bindUserEvents(),this.options.responsive?this.bindResponsiveEvents():this.attached=!0}bindUserEvents(){const t=this._listeners,e=this.platform,i=(i,s)=>{e.addEventListener(this,i,s),t[i]=s},s=(t,e,i)=>{t.offsetX=e,t.offsetY=i,this._eventHandler(t)};u(this.options.events,(t=>i(t,s)))}bindResponsiveEvents(){this._responsiveListeners||(this._responsiveListeners={});const t=this._responsiveListeners,e=this.platform,i=(i,s)=>{e.addEventListener(this,i,s),t[i]=s},s=(i,s)=>{t[i]&&(e.removeEventListener(this,i,s),delete t[i])},n=(t,e)=>{this.canvas&&this.resize(t,e)};let o;const a=()=>{s("attach",a),this.attached=!0,this.resize(),i("resize",n),i("detach",o)};o=()=>{this.attached=!1,s("resize",n),this._stop(),this._resize(0,0),i("attach",a)},e.isAttached(this.canvas)?a():o()}unbindEvents(){u(this._listeners,((t,e)=>{this.platform.removeEventListener(this,e,t)})),this._listeners={},u(this._responsiveListeners,((t,e)=>{this.platform.removeEventListener(this,e,t)})),this._responsiveListeners=void 0}updateHoverStyle(t,e,i){const s=i?"set":"remove";let n,o,a,r;for("dataset"===e&&(n=this.getDatasetMeta(t[0].datasetIndex),n.controller["_"+s+"DatasetHoverStyle"]()),a=0,r=t.length;a<r;++a){o=t[a];const e=o&&this.getDatasetMeta(o.datasetIndex).controller;e&&e[s+"HoverStyle"](o.element,o.datasetIndex,o.index)}}getActiveElements(){return this._active||[]}setActiveElements(t){const e=this._active||[],i=t.map((({datasetIndex:t,index:e})=>{const i=this.getDatasetMeta(t);if(!i)throw new Error("No dataset found at index "+t);return{datasetIndex:t,element:i.data[e],index:e}}));!f(i,e)&&(this._active=i,this._lastEvent=null,this._updateHoverStyles(i,e))}notifyPlugins(t,e,i){return this._plugins.notify(this,t,e,i)}isPluginEnabled(t){return 1===this._plugins._cache.filter((e=>e.plugin.id===t)).length}_updateHoverStyles(t,e,i){const s=this.options.hover,n=(t,e)=>t.filter((t=>!e.some((e=>t.datasetIndex===e.datasetIndex&&t.index===e.index)))),o=n(e,t),a=i?t:n(t,e);o.length&&this.updateHoverStyle(o,s.mode,!1),a.length&&s.mode&&this.updateHoverStyle(a,s.mode,!0)}_eventHandler(t,e){const i={event:t,replay:e,cancelable:!0,inChartArea:this.isPointInArea(t)},s=e=>(e.options.events||this.options.events).includes(t.native.type);if(!1===this.notifyPlugins("beforeEvent",i,s))return;const n=this._handleEvent(t,e,i.inChartArea);return i.cancelable=!1,this.notifyPlugins("afterEvent",i,s),(n||i.changed)&&this.render(),this}_handleEvent(t,e,i){const{_active:s=[],options:n}=this,o=e,a=this._getActiveElements(t,s,i,o),r=D(t),l=function(t,e,i,s){return i&&"mouseout"!==t.type?s?e:t:null}(t,this._lastEvent,i,r);i&&(this._lastEvent=null,d(n.onHover,[t,a,this],this),r&&d(n.onClick,[t,a,this],this));const h=!f(a,s);return(h||e)&&(this._active=a,this._updateHoverStyles(a,s,e)),this._lastEvent=l,h}_getActiveElements(t,e,i,s){if("mouseout"===t.type)return[];if(!i)return e;const n=this.options.hover;return this.getElementsAtEventForMode(t,n.mode,n,s)}}function Tn(){return u(An.instances,(t=>t._plugins.invalidate()))}function Ln(){throw new Error("This method is not implemented: Check that a complete date adapter is provided.")}class En{static override(t){Object.assign(En.prototype,t)}options;constructor(t){this.options=t||{}}init(){}formats(){return Ln()}parse(){return Ln()}format(){return Ln()}add(){return Ln()}diff(){return Ln()}startOf(){return Ln()}endOf(){return Ln()}}var Rn={_date:En};function In(t){const e=t.iScale,i=function(t,e){if(!t._cache.$bar){const i=t.getMatchingVisibleMetas(e);let s=[];for(let e=0,n=i.length;e<n;e++)s=s.concat(i[e].controller.getAllParsedValues(t));t._cache.$bar=lt(s.sort(((t,e)=>t-e)))}return t._cache.$bar}(e,t.type);let s,n,o,a,r=e._length;const l=()=>{32767!==o&&-32768!==o&&(k(a)&&(r=Math.min(r,Math.abs(o-a)||r)),a=o)};for(s=0,n=i.length;s<n;++s)o=e.getPixelForValue(i[s]),l();for(a=void 0,s=0,n=e.ticks.length;s<n;++s)o=e.getPixelForTick(s),l();return r}function zn(t,e,i,s){return n(t)?function(t,e,i,s){const n=i.parse(t[0],s),o=i.parse(t[1],s),a=Math.min(n,o),r=Math.max(n,o);let l=a,h=r;Math.abs(a)>Math.abs(r)&&(l=r,h=a),e[i.axis]=h,e._custom={barStart:l,barEnd:h,start:n,end:o,min:a,max:r}}(t,e,i,s):e[i.axis]=i.parse(t,s),e}function Fn(t,e,i,s){const n=t.iScale,o=t.vScale,a=n.getLabels(),r=n===o,l=[];let h,c,d,u;for(h=i,c=i+s;h<c;++h)u=e[h],d={},d[n.axis]=r||n.parse(a[h],h),l.push(zn(u,d,o,h));return l}function Vn(t){return t&&void 0!==t.barStart&&void 0!==t.barEnd}function Bn(t,e,i,s){let n=e.borderSkipped;const o={};if(!n)return void(t.borderSkipped=o);if(!0===n)return void(t.borderSkipped={top:!0,right:!0,bottom:!0,left:!0});const{start:a,end:r,reverse:l,top:h,bottom:c}=function(t){let e,i,s,n,o;return t.horizontal?(e=t.base>t.x,i="left",s="right"):(e=t.base<t.y,i="bottom",s="top"),e?(n="end",o="start"):(n="start",o="end"),{start:i,end:s,reverse:e,top:n,bottom:o}}(t);"middle"===n&&i&&(t.enableBorderRadius=!0,(i._top||0)===s?n=h:(i._bottom||0)===s?n=c:(o[Wn(c,a,r,l)]=!0,n=h)),o[Wn(n,a,r,l)]=!0,t.borderSkipped=o}function Wn(t,e,i,s){var n,o,a;return s?(a=i,t=Nn(t=(n=t)===(o=e)?a:n===a?o:n,i,e)):t=Nn(t,e,i),t}function Nn(t,e,i){return"start"===t?e:"end"===t?i:t}function Hn(t,{inflateAmount:e},i){t.inflateAmount="auto"===e?1===i?.33:0:e}class jn extends Ns{static id="doughnut";static defaults={datasetElementType:!1,dataElementType:"arc",animation:{animateRotate:!0,animateScale:!1},animations:{numbers:{type:"number",properties:["circumference","endAngle","innerRadius","outerRadius","startAngle","x","y","offset","borderWidth","spacing"]}},cutout:"50%",rotation:0,circumference:360,radius:"100%",spacing:0,indexAxis:"r"};static descriptors={_scriptable:t=>"spacing"!==t,_indexable:t=>"spacing"!==t&&!t.startsWith("borderDash")&&!t.startsWith("hoverBorderDash")};static overrides={aspectRatio:1,plugins:{legend:{labels:{generateLabels(t){const e=t.data;if(e.labels.length&&e.datasets.length){const{labels:{pointStyle:i,color:s}}=t.legend.options;return e.labels.map(((e,n)=>{const o=t.getDatasetMeta(0).controller.getStyle(n);return{text:e,fillStyle:o.backgroundColor,strokeStyle:o.borderColor,fontColor:s,lineWidth:o.borderWidth,pointStyle:i,hidden:!t.getDataVisibility(n),index:n}}))}return[]}},onClick(t,e,i){i.chart.toggleDataVisibility(e.index),i.chart.update()}}}};constructor(t,e){super(t,e),this.enableOptionSharing=!0,this.innerRadius=void 0,this.outerRadius=void 0,this.offsetX=void 0,this.offsetY=void 0}linkScales(){}parse(t,e){const i=this.getDataset().data,s=this._cachedMeta;if(!1===this._parsing)s._parsed=i;else{let n,a,r=t=>+i[t];if(o(i[t])){const{key:t="value"}=this._parsing;r=e=>+M(i[e],t)}for(n=t,a=t+e;n<a;++n)s._parsed[n]=r(n)}}_getRotation(){return $(this.options.rotation-90)}_getCircumference(){return $(this.options.circumference)}_getRotationExtents(){let t=O,e=-O;for(let i=0;i<this.chart.data.datasets.length;++i)if(this.chart.isDatasetVisible(i)&&this.chart.getDatasetMeta(i).type===this._type){const s=this.chart.getDatasetMeta(i).controller,n=s._getRotation(),o=s._getCircumference();t=Math.min(t,n),e=Math.max(e,n+o)}return{rotation:t,circumference:e-t}}update(t){const e=this.chart,{chartArea:i}=e,s=this._cachedMeta,n=s.data,o=this.getMaxBorderWidth()+this.getMaxOffset(n)+this.options.spacing,a=Math.max((Math.min(i.width,i.height)-o)/2,0),r=Math.min(h(this.options.cutout,a),1),l=this._getRingWeight(this.index),{circumference:d,rotation:u}=this._getRotationExtents(),{ratioX:f,ratioY:g,offsetX:p,offsetY:m}=function(t,e,i){let s=1,n=1,o=0,a=0;if(e<O){const r=t,l=r+e,h=Math.cos(r),c=Math.sin(r),d=Math.cos(l),u=Math.sin(l),f=(t,e,s)=>Z(t,r,l,!0)?1:Math.max(e,e*i,s,s*i),g=(t,e,s)=>Z(t,r,l,!0)?-1:Math.min(e,e*i,s,s*i),p=f(0,h,d),m=f(E,c,u),x=g(C,h,d),b=g(C+E,c,u);s=(p-x)/2,n=(m-b)/2,o=-(p+x)/2,a=-(m+b)/2}return{ratioX:s,ratioY:n,offsetX:o,offsetY:a}}(u,d,r),x=(i.width-o)/f,b=(i.height-o)/g,_=Math.max(Math.min(x,b)/2,0),y=c(this.options.radius,_),v=(y-Math.max(y*r,0))/this._getVisibleDatasetWeightTotal();this.offsetX=p*y,this.offsetY=m*y,s.total=this.calculateTotal(),this.outerRadius=y-v*this._getRingWeightOffset(this.index),this.innerRadius=Math.max(this.outerRadius-v*l,0),this.updateElements(n,0,n.length,t)}_circumference(t,e){const i=this.options,s=this._cachedMeta,n=this._getCircumference();return e&&i.animation.animateRotate||!this.chart.getDataVisibility(t)||null===s._parsed[t]||s.data[t].hidden?0:this.calculateCircumference(s._parsed[t]*n/O)}updateElements(t,e,i,s){const n="reset"===s,o=this.chart,a=o.chartArea,r=o.options.animation,l=(a.left+a.right)/2,h=(a.top+a.bottom)/2,c=n&&r.animateScale,d=c?0:this.innerRadius,u=c?0:this.outerRadius,{sharedOptions:f,includeOptions:g}=this._getSharedOptions(e,s);let p,m=this._getRotation();for(p=0;p<e;++p)m+=this._circumference(p,n);for(p=e;p<e+i;++p){const e=this._circumference(p,n),i=t[p],o={x:l+this.offsetX,y:h+this.offsetY,startAngle:m,endAngle:m+e,circumference:e,outerRadius:u,innerRadius:d};g&&(o.options=f||this.resolveDataElementOptions(p,i.active?"active":s)),m+=e,this.updateElement(i,p,o,s)}}calculateTotal(){const t=this._cachedMeta,e=t.data;let i,s=0;for(i=0;i<e.length;i++){const n=t._parsed[i];null===n||isNaN(n)||!this.chart.getDataVisibility(i)||e[i].hidden||(s+=Math.abs(n))}return s}calculateCircumference(t){const e=this._cachedMeta.total;return e>0&&!isNaN(t)?O*(Math.abs(t)/e):0}getLabelAndValue(t){const e=this._cachedMeta,i=this.chart,s=i.data.labels||[],n=ne(e._parsed[t],i.options.locale);return{label:s[t]||"",value:n}}getMaxBorderWidth(t){let e=0;const i=this.chart;let s,n,o,a,r;if(!t)for(s=0,n=i.data.datasets.length;s<n;++s)if(i.isDatasetVisible(s)){o=i.getDatasetMeta(s),t=o.data,a=o.controller;break}if(!t)return 0;for(s=0,n=t.length;s<n;++s)r=a.resolveDataElementOptions(s),"inner"!==r.borderAlign&&(e=Math.max(e,r.borderWidth||0,r.hoverBorderWidth||0));return e}getMaxOffset(t){let e=0;for(let i=0,s=t.length;i<s;++i){const t=this.resolveDataElementOptions(i);e=Math.max(e,t.offset||0,t.hoverOffset||0)}return e}_getRingWeightOffset(t){let e=0;for(let i=0;i<t;++i)this.chart.isDatasetVisible(i)&&(e+=this._getRingWeight(i));return e}_getRingWeight(t){return Math.max(l(this.chart.data.datasets[t].weight,1),0)}_getVisibleDatasetWeightTotal(){return this._getRingWeightOffset(this.chart.data.datasets.length)||1}}class $n extends Ns{static id="polarArea";static defaults={dataElementType:"arc",animation:{animateRotate:!0,animateScale:!0},animations:{numbers:{type:"number",properties:["x","y","startAngle","endAngle","innerRadius","outerRadius"]}},indexAxis:"r",startAngle:0};static overrides={aspectRatio:1,plugins:{legend:{labels:{generateLabels(t){const e=t.data;if(e.labels.length&&e.datasets.length){const{labels:{pointStyle:i,color:s}}=t.legend.options;return e.labels.map(((e,n)=>{const o=t.getDatasetMeta(0).controller.getStyle(n);return{text:e,fillStyle:o.backgroundColor,strokeStyle:o.borderColor,fontColor:s,lineWidth:o.borderWidth,pointStyle:i,hidden:!t.getDataVisibility(n),index:n}}))}return[]}},onClick(t,e,i){i.chart.toggleDataVisibility(e.index),i.chart.update()}}},scales:{r:{type:"radialLinear",angleLines:{display:!1},beginAtZero:!0,grid:{circular:!0},pointLabels:{display:!1},startAngle:0}}};constructor(t,e){super(t,e),this.innerRadius=void 0,this.outerRadius=void 0}getLabelAndValue(t){const e=this._cachedMeta,i=this.chart,s=i.data.labels||[],n=ne(e._parsed[t].r,i.options.locale);return{label:s[t]||"",value:n}}parseObjectData(t,e,i,s){return ii.bind(this)(t,e,i,s)}update(t){const e=this._cachedMeta.data;this._updateRadius(),this.updateElements(e,0,e.length,t)}getMinMax(){const t=this._cachedMeta,e={min:Number.POSITIVE_INFINITY,max:Number.NEGATIVE_INFINITY};return t.data.forEach(((t,i)=>{const s=this.getParsed(i).r;!isNaN(s)&&this.chart.getDataVisibility(i)&&(s<e.min&&(e.min=s),s>e.max&&(e.max=s))})),e}_updateRadius(){const t=this.chart,e=t.chartArea,i=t.options,s=Math.min(e.right-e.left,e.bottom-e.top),n=Math.max(s/2,0),o=(n-Math.max(i.cutoutPercentage?n/100*i.cutoutPercentage:1,0))/t.getVisibleDatasetCount();this.outerRadius=n-o*this.index,this.innerRadius=this.outerRadius-o}updateElements(t,e,i,s){const n="reset"===s,o=this.chart,a=o.options.animation,r=this._cachedMeta.rScale,l=r.xCenter,h=r.yCenter,c=r.getIndexAngle(0)-.5*C;let d,u=c;const f=360/this.countVisibleElements();for(d=0;d<e;++d)u+=this._computeAngle(d,s,f);for(d=e;d<e+i;d++){const e=t[d];let i=u,g=u+this._computeAngle(d,s,f),p=o.getDataVisibility(d)?r.getDistanceFromCenterForValue(this.getParsed(d).r):0;u=g,n&&(a.animateScale&&(p=0),a.animateRotate&&(i=g=c));const m={x:l,y:h,innerRadius:0,outerRadius:p,startAngle:i,endAngle:g,options:this.resolveDataElementOptions(d,e.active?"active":s)};this.updateElement(e,d,m,s)}}countVisibleElements(){const t=this._cachedMeta;let e=0;return t.data.forEach(((t,i)=>{!isNaN(this.getParsed(i).r)&&this.chart.getDataVisibility(i)&&e++})),e}_computeAngle(t,e,i){return this.chart.getDataVisibility(t)?$(this.resolveDataElementOptions(t,e).angle||i):0}}var Yn=Object.freeze({__proto__:null,BarController:class extends Ns{static id="bar";static defaults={datasetElementType:!1,dataElementType:"bar",categoryPercentage:.8,barPercentage:.9,grouped:!0,animations:{numbers:{type:"number",properties:["x","y","base","width","height"]}}};static overrides={scales:{_index_:{type:"category",offset:!0,grid:{offset:!0}},_value_:{type:"linear",beginAtZero:!0}}};parsePrimitiveData(t,e,i,s){return Fn(t,e,i,s)}parseArrayData(t,e,i,s){return Fn(t,e,i,s)}parseObjectData(t,e,i,s){const{iScale:n,vScale:o}=t,{xAxisKey:a="x",yAxisKey:r="y"}=this._parsing,l="x"===n.axis?a:r,h="x"===o.axis?a:r,c=[];let d,u,f,g;for(d=i,u=i+s;d<u;++d)g=e[d],f={},f[n.axis]=n.parse(M(g,l),d),c.push(zn(M(g,h),f,o,d));return c}updateRangeFromParsed(t,e,i,s){super.updateRangeFromParsed(t,e,i,s);const n=i._custom;n&&e===this._cachedMeta.vScale&&(t.min=Math.min(t.min,n.min),t.max=Math.max(t.max,n.max))}getMaxOverflow(){return 0}getLabelAndValue(t){const e=this._cachedMeta,{iScale:i,vScale:s}=e,n=this.getParsed(t),o=n._custom,a=Vn(o)?"["+o.start+", "+o.end+"]":""+s.getLabelForValue(n[s.axis]);return{label:""+i.getLabelForValue(n[i.axis]),value:a}}initialize(){this.enableOptionSharing=!0,super.initialize();this._cachedMeta.stack=this.getDataset().stack}update(t){const e=this._cachedMeta;this.updateElements(e.data,0,e.data.length,t)}updateElements(t,e,i,n){const o="reset"===n,{index:a,_cachedMeta:{vScale:r}}=this,l=r.getBasePixel(),h=r.isHorizontal(),c=this._getRuler(),{sharedOptions:d,includeOptions:u}=this._getSharedOptions(e,n);for(let f=e;f<e+i;f++){const e=this.getParsed(f),i=o||s(e[r.axis])?{base:l,head:l}:this._calculateBarValuePixels(f),g=this._calculateBarIndexPixels(f,c),p=(e._stacks||{})[r.axis],m={horizontal:h,base:i.base,enableBorderRadius:!p||Vn(e._custom)||a===p._top||a===p._bottom,x:h?i.head:g.center,y:h?g.center:i.head,height:h?g.size:Math.abs(i.size),width:h?Math.abs(i.size):g.size};u&&(m.options=d||this.resolveDataElementOptions(f,t[f].active?"active":n));const x=m.options||t[f].options;Bn(m,x,p,a),Hn(m,x,c.ratio),this.updateElement(t[f],f,m,n)}}_getStacks(t,e){const{iScale:i}=this._cachedMeta,n=i.getMatchingVisibleMetas(this._type).filter((t=>t.controller.options.grouped)),o=i.options.stacked,a=[],r=this._cachedMeta.controller.getParsed(e),l=r&&r[i.axis],h=t=>{const e=t._parsed.find((t=>t[i.axis]===l)),n=e&&e[t.vScale.axis];if(s(n)||isNaN(n))return!0};for(const i of n)if((void 0===e||!h(i))&&((!1===o||-1===a.indexOf(i.stack)||void 0===o&&void 0===i.stack)&&a.push(i.stack),i.index===t))break;return a.length||a.push(void 0),a}_getStackCount(t){return this._getStacks(void 0,t).length}_getStackIndex(t,e,i){const s=this._getStacks(t,i),n=void 0!==e?s.indexOf(e):-1;return-1===n?s.length-1:n}_getRuler(){const t=this.options,e=this._cachedMeta,i=e.iScale,s=[];let n,o;for(n=0,o=e.data.length;n<o;++n)s.push(i.getPixelForValue(this.getParsed(n)[i.axis],n));const a=t.barThickness;return{min:a||In(e),pixels:s,start:i._startPixel,end:i._endPixel,stackCount:this._getStackCount(),scale:i,grouped:t.grouped,ratio:a?1:t.categoryPercentage*t.barPercentage}}_calculateBarValuePixels(t){const{_cachedMeta:{vScale:e,_stacked:i,index:n},options:{base:o,minBarLength:a}}=this,r=o||0,l=this.getParsed(t),h=l._custom,c=Vn(h);let d,u,f=l[e.axis],g=0,p=i?this.applyStack(e,l,i):f;p!==f&&(g=p-f,p=f),c&&(f=h.barStart,p=h.barEnd-h.barStart,0!==f&&F(f)!==F(h.barEnd)&&(g=0),g+=f);const m=s(o)||c?g:o;let x=e.getPixelForValue(m);if(d=this.chart.getDataVisibility(t)?e.getPixelForValue(g+p):x,u=d-x,Math.abs(u)<a){u=function(t,e,i){return 0!==t?F(t):(e.isHorizontal()?1:-1)*(e.min>=i?1:-1)}(u,e,r)*a,f===r&&(x-=u/2);const t=e.getPixelForDecimal(0),s=e.getPixelForDecimal(1),o=Math.min(t,s),h=Math.max(t,s);x=Math.max(Math.min(x,h),o),d=x+u,i&&!c&&(l._stacks[e.axis]._visualValues[n]=e.getValueForPixel(d)-e.getValueForPixel(x))}if(x===e.getPixelForValue(r)){const t=F(u)*e.getLineWidthForValue(r)/2;x+=t,u-=t}return{size:u,base:x,head:d,center:d+u/2}}_calculateBarIndexPixels(t,e){const i=e.scale,n=this.options,o=n.skipNull,a=l(n.maxBarThickness,1/0);let r,h;if(e.grouped){const i=o?this._getStackCount(t):e.stackCount,l="flex"===n.barThickness?function(t,e,i,s){const n=e.pixels,o=n[t];let a=t>0?n[t-1]:null,r=t<n.length-1?n[t+1]:null;const l=i.categoryPercentage;null===a&&(a=o-(null===r?e.end-e.start:r-o)),null===r&&(r=o+o-a);const h=o-(o-Math.min(a,r))/2*l;return{chunk:Math.abs(r-a)/2*l/s,ratio:i.barPercentage,start:h}}(t,e,n,i):function(t,e,i,n){const o=i.barThickness;let a,r;return s(o)?(a=e.min*i.categoryPercentage,r=i.barPercentage):(a=o*n,r=1),{chunk:a/n,ratio:r,start:e.pixels[t]-a/2}}(t,e,n,i),c=this._getStackIndex(this.index,this._cachedMeta.stack,o?t:void 0);r=l.start+l.chunk*c+l.chunk/2,h=Math.min(a,l.chunk*l.ratio)}else r=i.getPixelForValue(this.getParsed(t)[i.axis],t),h=Math.min(a,e.min*e.ratio);return{base:r-h/2,head:r+h/2,center:r,size:h}}draw(){const t=this._cachedMeta,e=t.vScale,i=t.data,s=i.length;let n=0;for(;n<s;++n)null===this.getParsed(n)[e.axis]||i[n].hidden||i[n].draw(this._ctx)}},BubbleController:class extends Ns{static id="bubble";static defaults={datasetElementType:!1,dataElementType:"point",animations:{numbers:{type:"number",properties:["x","y","borderWidth","radius"]}}};static overrides={scales:{x:{type:"linear"},y:{type:"linear"}}};initialize(){this.enableOptionSharing=!0,super.initialize()}parsePrimitiveData(t,e,i,s){const n=super.parsePrimitiveData(t,e,i,s);for(let t=0;t<n.length;t++)n[t]._custom=this.resolveDataElementOptions(t+i).radius;return n}parseArrayData(t,e,i,s){const n=super.parseArrayData(t,e,i,s);for(let t=0;t<n.length;t++){const s=e[i+t];n[t]._custom=l(s[2],this.resolveDataElementOptions(t+i).radius)}return n}parseObjectData(t,e,i,s){const n=super.parseObjectData(t,e,i,s);for(let t=0;t<n.length;t++){const s=e[i+t];n[t]._custom=l(s&&s.r&&+s.r,this.resolveDataElementOptions(t+i).radius)}return n}getMaxOverflow(){const t=this._cachedMeta.data;let e=0;for(let i=t.length-1;i>=0;--i)e=Math.max(e,t[i].size(this.resolveDataElementOptions(i))/2);return e>0&&e}getLabelAndValue(t){const e=this._cachedMeta,i=this.chart.data.labels||[],{xScale:s,yScale:n}=e,o=this.getParsed(t),a=s.getLabelForValue(o.x),r=n.getLabelForValue(o.y),l=o._custom;return{label:i[t]||"",value:"("+a+", "+r+(l?", "+l:"")+")"}}update(t){const e=this._cachedMeta.data;this.updateElements(e,0,e.length,t)}updateElements(t,e,i,s){const n="reset"===s,{iScale:o,vScale:a}=this._cachedMeta,{sharedOptions:r,includeOptions:l}=this._getSharedOptions(e,s),h=o.axis,c=a.axis;for(let d=e;d<e+i;d++){const e=t[d],i=!n&&this.getParsed(d),u={},f=u[h]=n?o.getPixelForDecimal(.5):o.getPixelForValue(i[h]),g=u[c]=n?a.getBasePixel():a.getPixelForValue(i[c]);u.skip=isNaN(f)||isNaN(g),l&&(u.options=r||this.resolveDataElementOptions(d,e.active?"active":s),n&&(u.options.radius=0)),this.updateElement(e,d,u,s)}}resolveDataElementOptions(t,e){const i=this.getParsed(t);let s=super.resolveDataElementOptions(t,e);s.$shared&&(s=Object.assign({},s,{$shared:!1}));const n=s.radius;return"active"!==e&&(s.radius=0),s.radius+=l(i&&i._custom,n),s}},DoughnutController:jn,LineController:class extends Ns{static id="line";static defaults={datasetElementType:"line",dataElementType:"point",showLine:!0,spanGaps:!1};static overrides={scales:{_index_:{type:"category"},_value_:{type:"linear"}}};initialize(){this.enableOptionSharing=!0,this.supportsDecimation=!0,super.initialize()}update(t){const e=this._cachedMeta,{dataset:i,data:s=[],_dataset:n}=e,o=this.chart._animationsDisabled;let{start:a,count:r}=pt(e,s,o);this._drawStart=a,this._drawCount=r,mt(e)&&(a=0,r=s.length),i._chart=this.chart,i._datasetIndex=this.index,i._decimated=!!n._decimated,i.points=s;const l=this.resolveDatasetElementOptions(t);this.options.showLine||(l.borderWidth=0),l.segment=this.options.segment,this.updateElement(i,void 0,{animated:!o,options:l},t),this.updateElements(s,a,r,t)}updateElements(t,e,i,n){const o="reset"===n,{iScale:a,vScale:r,_stacked:l,_dataset:h}=this._cachedMeta,{sharedOptions:c,includeOptions:d}=this._getSharedOptions(e,n),u=a.axis,f=r.axis,{spanGaps:g,segment:p}=this.options,m=N(g)?g:Number.POSITIVE_INFINITY,x=this.chart._animationsDisabled||o||"none"===n,b=e+i,_=t.length;let y=e>0&&this.getParsed(e-1);for(let i=0;i<_;++i){const g=t[i],_=x?g:{};if(i<e||i>=b){_.skip=!0;continue}const v=this.getParsed(i),M=s(v[f]),w=_[u]=a.getPixelForValue(v[u],i),k=_[f]=o||M?r.getBasePixel():r.getPixelForValue(l?this.applyStack(r,v,l):v[f],i);_.skip=isNaN(w)||isNaN(k)||M,_.stop=i>0&&Math.abs(v[u]-y[u])>m,p&&(_.parsed=v,_.raw=h.data[i]),d&&(_.options=c||this.resolveDataElementOptions(i,g.active?"active":n)),x||this.updateElement(g,i,_,n),y=v}}getMaxOverflow(){const t=this._cachedMeta,e=t.dataset,i=e.options&&e.options.borderWidth||0,s=t.data||[];if(!s.length)return i;const n=s[0].size(this.resolveDataElementOptions(0)),o=s[s.length-1].size(this.resolveDataElementOptions(s.length-1));return Math.max(i,n,o)/2}draw(){const t=this._cachedMeta;t.dataset.updateControlPoints(this.chart.chartArea,t.iScale.axis),super.draw()}},PieController:class extends jn{static id="pie";static defaults={cutout:0,rotation:0,circumference:360,radius:"100%"}},PolarAreaController:$n,RadarController:class extends Ns{static id="radar";static defaults={datasetElementType:"line",dataElementType:"point",indexAxis:"r",showLine:!0,elements:{line:{fill:"start"}}};static overrides={aspectRatio:1,scales:{r:{type:"radialLinear"}}};getLabelAndValue(t){const e=this._cachedMeta.vScale,i=this.getParsed(t);return{label:e.getLabels()[t],value:""+e.getLabelForValue(i[e.axis])}}parseObjectData(t,e,i,s){return ii.bind(this)(t,e,i,s)}update(t){const e=this._cachedMeta,i=e.dataset,s=e.data||[],n=e.iScale.getLabels();if(i.points=s,"resize"!==t){const e=this.resolveDatasetElementOptions(t);this.options.showLine||(e.borderWidth=0);const o={_loop:!0,_fullLoop:n.length===s.length,options:e};this.updateElement(i,void 0,o,t)}this.updateElements(s,0,s.length,t)}updateElements(t,e,i,s){const n=this._cachedMeta.rScale,o="reset"===s;for(let a=e;a<e+i;a++){const e=t[a],i=this.resolveDataElementOptions(a,e.active?"active":s),r=n.getPointPositionForValue(a,this.getParsed(a).r),l=o?n.xCenter:r.x,h=o?n.yCenter:r.y,c={x:l,y:h,angle:r.angle,skip:isNaN(l)||isNaN(h),options:i};this.updateElement(e,a,c,s)}}},ScatterController:class extends Ns{static id="scatter";static defaults={datasetElementType:!1,dataElementType:"point",showLine:!1,fill:!1};static overrides={interaction:{mode:"point"},scales:{x:{type:"linear"},y:{type:"linear"}}};getLabelAndValue(t){const e=this._cachedMeta,i=this.chart.data.labels||[],{xScale:s,yScale:n}=e,o=this.getParsed(t),a=s.getLabelForValue(o.x),r=n.getLabelForValue(o.y);return{label:i[t]||"",value:"("+a+", "+r+")"}}update(t){const e=this._cachedMeta,{data:i=[]}=e,s=this.chart._animationsDisabled;let{start:n,count:o}=pt(e,i,s);if(this._drawStart=n,this._drawCount=o,mt(e)&&(n=0,o=i.length),this.options.showLine){this.datasetElementType||this.addElements();const{dataset:n,_dataset:o}=e;n._chart=this.chart,n._datasetIndex=this.index,n._decimated=!!o._decimated,n.points=i;const a=this.resolveDatasetElementOptions(t);a.segment=this.options.segment,this.updateElement(n,void 0,{animated:!s,options:a},t)}else this.datasetElementType&&(delete e.dataset,this.datasetElementType=!1);this.updateElements(i,n,o,t)}addElements(){const{showLine:t}=this.options;!this.datasetElementType&&t&&(this.datasetElementType=this.chart.registry.getElement("line")),super.addElements()}updateElements(t,e,i,n){const o="reset"===n,{iScale:a,vScale:r,_stacked:l,_dataset:h}=this._cachedMeta,c=this.resolveDataElementOptions(e,n),d=this.getSharedOptions(c),u=this.includeOptions(n,d),f=a.axis,g=r.axis,{spanGaps:p,segment:m}=this.options,x=N(p)?p:Number.POSITIVE_INFINITY,b=this.chart._animationsDisabled||o||"none"===n;let _=e>0&&this.getParsed(e-1);for(let c=e;c<e+i;++c){const e=t[c],i=this.getParsed(c),p=b?e:{},y=s(i[g]),v=p[f]=a.getPixelForValue(i[f],c),M=p[g]=o||y?r.getBasePixel():r.getPixelForValue(l?this.applyStack(r,i,l):i[g],c);p.skip=isNaN(v)||isNaN(M)||y,p.stop=c>0&&Math.abs(i[f]-_[f])>x,m&&(p.parsed=i,p.raw=h.data[c]),u&&(p.options=d||this.resolveDataElementOptions(c,e.active?"active":n)),b||this.updateElement(e,c,p,n),_=i}this.updateSharedOptions(d,n,c)}getMaxOverflow(){const t=this._cachedMeta,e=t.data||[];if(!this.options.showLine){let t=0;for(let i=e.length-1;i>=0;--i)t=Math.max(t,e[i].size(this.resolveDataElementOptions(i))/2);return t>0&&t}const i=t.dataset,s=i.options&&i.options.borderWidth||0;if(!e.length)return s;const n=e[0].size(this.resolveDataElementOptions(0)),o=e[e.length-1].size(this.resolveDataElementOptions(e.length-1));return Math.max(s,n,o)/2}}});function Un(t,e,i,s){const n=vi(t.options.borderRadius,["outerStart","outerEnd","innerStart","innerEnd"]);const o=(i-e)/2,a=Math.min(o,s*e/2),r=t=>{const e=(i-Math.min(o,t))*s/2;return J(t,0,Math.min(o,e))};return{outerStart:r(n.outerStart),outerEnd:r(n.outerEnd),innerStart:J(n.innerStart,0,a),innerEnd:J(n.innerEnd,0,a)}}function Xn(t,e,i,s){return{x:i+t*Math.cos(e),y:s+t*Math.sin(e)}}function qn(t,e,i,s,n,o){const{x:a,y:r,startAngle:l,pixelMargin:h,innerRadius:c}=e,d=Math.max(e.outerRadius+s+i-h,0),u=c>0?c+s+i+h:0;let f=0;const g=n-l;if(s){const t=((c>0?c-s:0)+(d>0?d-s:0))/2;f=(g-(0!==t?g*t/(t+s):g))/2}const p=(g-Math.max(.001,g*d-i/C)/d)/2,m=l+p+f,x=n-p-f,{outerStart:b,outerEnd:_,innerStart:y,innerEnd:v}=Un(e,u,d,x-m),M=d-b,w=d-_,k=m+b/M,S=x-_/w,P=u+y,D=u+v,O=m+y/P,A=x-v/D;if(t.beginPath(),o){const e=(k+S)/2;if(t.arc(a,r,d,k,e),t.arc(a,r,d,e,S),_>0){const e=Xn(w,S,a,r);t.arc(e.x,e.y,_,S,x+E)}const i=Xn(D,x,a,r);if(t.lineTo(i.x,i.y),v>0){const e=Xn(D,A,a,r);t.arc(e.x,e.y,v,x+E,A+Math.PI)}const s=(x-v/u+(m+y/u))/2;if(t.arc(a,r,u,x-v/u,s,!0),t.arc(a,r,u,s,m+y/u,!0),y>0){const e=Xn(P,O,a,r);t.arc(e.x,e.y,y,O+Math.PI,m-E)}const n=Xn(M,m,a,r);if(t.lineTo(n.x,n.y),b>0){const e=Xn(M,k,a,r);t.arc(e.x,e.y,b,m-E,k)}}else{t.moveTo(a,r);const e=Math.cos(k)*d+a,i=Math.sin(k)*d+r;t.lineTo(e,i);const s=Math.cos(S)*d+a,n=Math.sin(S)*d+r;t.lineTo(s,n)}t.closePath()}function Kn(t,e,i,s,n){const{fullCircles:o,startAngle:a,circumference:r,options:l}=e,{borderWidth:h,borderJoinStyle:c,borderDash:d,borderDashOffset:u}=l,f="inner"===l.borderAlign;if(!h)return;t.setLineDash(d||[]),t.lineDashOffset=u,f?(t.lineWidth=2*h,t.lineJoin=c||"round"):(t.lineWidth=h,t.lineJoin=c||"bevel");let g=e.endAngle;if(o){qn(t,e,i,s,g,n);for(let e=0;e<o;++e)t.stroke();isNaN(r)||(g=a+(r%O||O))}f&&function(t,e,i){const{startAngle:s,pixelMargin:n,x:o,y:a,outerRadius:r,innerRadius:l}=e;let h=n/r;t.beginPath(),t.arc(o,a,r,s-h,i+h),l>n?(h=n/l,t.arc(o,a,l,i+h,s-h,!0)):t.arc(o,a,n,i+E,s-E),t.closePath(),t.clip()}(t,e,g),o||(qn(t,e,i,s,g,n),t.stroke())}function Gn(t,e,i=e){t.lineCap=l(i.borderCapStyle,e.borderCapStyle),t.setLineDash(l(i.borderDash,e.borderDash)),t.lineDashOffset=l(i.borderDashOffset,e.borderDashOffset),t.lineJoin=l(i.borderJoinStyle,e.borderJoinStyle),t.lineWidth=l(i.borderWidth,e.borderWidth),t.strokeStyle=l(i.borderColor,e.borderColor)}function Zn(t,e,i){t.lineTo(i.x,i.y)}function Jn(t,e,i={}){const s=t.length,{start:n=0,end:o=s-1}=i,{start:a,end:r}=e,l=Math.max(n,a),h=Math.min(o,r),c=n<a&&o<a||n>r&&o>r;return{count:s,start:l,loop:e.loop,ilen:h<l&&!c?s+h-l:h-l}}function Qn(t,e,i,s){const{points:n,options:o}=e,{count:a,start:r,loop:l,ilen:h}=Jn(n,i,s),c=function(t){return t.stepped?Fe:t.tension||"monotone"===t.cubicInterpolationMode?Ve:Zn}(o);let d,u,f,{move:g=!0,reverse:p}=s||{};for(d=0;d<=h;++d)u=n[(r+(p?h-d:d))%a],u.skip||(g?(t.moveTo(u.x,u.y),g=!1):c(t,f,u,p,o.stepped),f=u);return l&&(u=n[(r+(p?h:0))%a],c(t,f,u,p,o.stepped)),!!l}function to(t,e,i,s){const n=e.points,{count:o,start:a,ilen:r}=Jn(n,i,s),{move:l=!0,reverse:h}=s||{};let c,d,u,f,g,p,m=0,x=0;const b=t=>(a+(h?r-t:t))%o,_=()=>{f!==g&&(t.lineTo(m,g),t.lineTo(m,f),t.lineTo(m,p))};for(l&&(d=n[b(0)],t.moveTo(d.x,d.y)),c=0;c<=r;++c){if(d=n[b(c)],d.skip)continue;const e=d.x,i=d.y,s=0|e;s===u?(i<f?f=i:i>g&&(g=i),m=(x*m+e)/++x):(_(),t.lineTo(e,i),u=s,x=0,f=g=i),p=i}_()}function eo(t){const e=t.options,i=e.borderDash&&e.borderDash.length;return!(t._decimated||t._loop||e.tension||"monotone"===e.cubicInterpolationMode||e.stepped||i)?to:Qn}const io="function"==typeof Path2D;function so(t,e,i,s){io&&!e.options.segment?function(t,e,i,s){let n=e._path;n||(n=e._path=new Path2D,e.path(n,i,s)&&n.closePath()),Gn(t,e.options),t.stroke(n)}(t,e,i,s):function(t,e,i,s){const{segments:n,options:o}=e,a=eo(e);for(const r of n)Gn(t,o,r.style),t.beginPath(),a(t,e,r,{start:i,end:i+s-1})&&t.closePath(),t.stroke()}(t,e,i,s)}class no extends Hs{static id="line";static defaults={borderCapStyle:"butt",borderDash:[],borderDashOffset:0,borderJoinStyle:"miter",borderWidth:3,capBezierPoints:!0,cubicInterpolationMode:"default",fill:!1,spanGaps:!1,stepped:!1,tension:0};static defaultRoutes={backgroundColor:"backgroundColor",borderColor:"borderColor"};static descriptors={_scriptable:!0,_indexable:t=>"borderDash"!==t&&"fill"!==t};constructor(t){super(),this.animated=!0,this.options=void 0,this._chart=void 0,this._loop=void 0,this._fullLoop=void 0,this._path=void 0,this._points=void 0,this._segments=void 0,this._decimated=!1,this._pointsUpdated=!1,this._datasetIndex=void 0,t&&Object.assign(this,t)}updateControlPoints(t,e){const i=this.options;if((i.tension||"monotone"===i.cubicInterpolationMode)&&!i.stepped&&!this._pointsUpdated){const s=i.spanGaps?this._loop:this._fullLoop;hi(this._points,i,t,s,e),this._pointsUpdated=!0}}set points(t){this._points=t,delete this._segments,delete this._path,this._pointsUpdated=!1}get points(){return this._points}get segments(){return this._segments||(this._segments=zi(this,this.options.segment))}first(){const t=this.segments,e=this.points;return t.length&&e[t[0].start]}last(){const t=this.segments,e=this.points,i=t.length;return i&&e[t[i-1].end]}interpolate(t,e){const i=this.options,s=t[e],n=this.points,o=Ii(this,{property:e,start:s,end:s});if(!o.length)return;const a=[],r=function(t){return t.stepped?pi:t.tension||"monotone"===t.cubicInterpolationMode?mi:gi}(i);let l,h;for(l=0,h=o.length;l<h;++l){const{start:h,end:c}=o[l],d=n[h],u=n[c];if(d===u){a.push(d);continue}const f=r(d,u,Math.abs((s-d[e])/(u[e]-d[e])),i.stepped);f[e]=t[e],a.push(f)}return 1===a.length?a[0]:a}pathSegment(t,e,i){return eo(this)(t,this,e,i)}path(t,e,i){const s=this.segments,n=eo(this);let o=this._loop;e=e||0,i=i||this.points.length-e;for(const a of s)o&=n(t,this,a,{start:e,end:e+i-1});return!!o}draw(t,e,i,s){const n=this.options||{};(this.points||[]).length&&n.borderWidth&&(t.save(),so(t,this,i,s),t.restore()),this.animated&&(this._pointsUpdated=!1,this._path=void 0)}}function oo(t,e,i,s){const n=t.options,{[i]:o}=t.getProps([i],s);return Math.abs(e-o)<n.radius+n.hitRadius}function ao(t,e){const{x:i,y:s,base:n,width:o,height:a}=t.getProps(["x","y","base","width","height"],e);let r,l,h,c,d;return t.horizontal?(d=a/2,r=Math.min(i,n),l=Math.max(i,n),h=s-d,c=s+d):(d=o/2,r=i-d,l=i+d,h=Math.min(s,n),c=Math.max(s,n)),{left:r,top:h,right:l,bottom:c}}function ro(t,e,i,s){return t?0:J(e,i,s)}function lo(t){const e=ao(t),i=e.right-e.left,s=e.bottom-e.top,n=function(t,e,i){const s=t.options.borderWidth,n=t.borderSkipped,o=Mi(s);return{t:ro(n.top,o.top,0,i),r:ro(n.right,o.right,0,e),b:ro(n.bottom,o.bottom,0,i),l:ro(n.left,o.left,0,e)}}(t,i/2,s/2),a=function(t,e,i){const{enableBorderRadius:s}=t.getProps(["enableBorderRadius"]),n=t.options.borderRadius,a=wi(n),r=Math.min(e,i),l=t.borderSkipped,h=s||o(n);return{topLeft:ro(!h||l.top||l.left,a.topLeft,0,r),topRight:ro(!h||l.top||l.right,a.topRight,0,r),bottomLeft:ro(!h||l.bottom||l.left,a.bottomLeft,0,r),bottomRight:ro(!h||l.bottom||l.right,a.bottomRight,0,r)}}(t,i/2,s/2);return{outer:{x:e.left,y:e.top,w:i,h:s,radius:a},inner:{x:e.left+n.l,y:e.top+n.t,w:i-n.l-n.r,h:s-n.t-n.b,radius:{topLeft:Math.max(0,a.topLeft-Math.max(n.t,n.l)),topRight:Math.max(0,a.topRight-Math.max(n.t,n.r)),bottomLeft:Math.max(0,a.bottomLeft-Math.max(n.b,n.l)),bottomRight:Math.max(0,a.bottomRight-Math.max(n.b,n.r))}}}}function ho(t,e,i,s){const n=null===e,o=null===i,a=t&&!(n&&o)&&ao(t,s);return a&&(n||tt(e,a.left,a.right))&&(o||tt(i,a.top,a.bottom))}function co(t,e){t.rect(e.x,e.y,e.w,e.h)}function uo(t,e,i={}){const s=t.x!==i.x?-e:0,n=t.y!==i.y?-e:0,o=(t.x+t.w!==i.x+i.w?e:0)-s,a=(t.y+t.h!==i.y+i.h?e:0)-n;return{x:t.x+s,y:t.y+n,w:t.w+o,h:t.h+a,radius:t.radius}}var fo=Object.freeze({__proto__:null,ArcElement:class extends Hs{static id="arc";static defaults={borderAlign:"center",borderColor:"#fff",borderDash:[],borderDashOffset:0,borderJoinStyle:void 0,borderRadius:0,borderWidth:2,offset:0,spacing:0,angle:void 0,circular:!0};static defaultRoutes={backgroundColor:"backgroundColor"};static descriptors={_scriptable:!0,_indexable:t=>"borderDash"!==t};circumference;endAngle;fullCircles;innerRadius;outerRadius;pixelMargin;startAngle;constructor(t){super(),this.options=void 0,this.circumference=void 0,this.startAngle=void 0,this.endAngle=void 0,this.innerRadius=void 0,this.outerRadius=void 0,this.pixelMargin=0,this.fullCircles=0,t&&Object.assign(this,t)}inRange(t,e,i){const s=this.getProps(["x","y"],i),{angle:n,distance:o}=X(s,{x:t,y:e}),{startAngle:a,endAngle:r,innerRadius:h,outerRadius:c,circumference:d}=this.getProps(["startAngle","endAngle","innerRadius","outerRadius","circumference"],i),u=(this.options.spacing+this.options.borderWidth)/2,f=l(d,r-a),g=Z(n,a,r)&&a!==r,p=f>=O||g,m=tt(o,h+u,c+u);return p&&m}getCenterPoint(t){const{x:e,y:i,startAngle:s,endAngle:n,innerRadius:o,outerRadius:a}=this.getProps(["x","y","startAngle","endAngle","innerRadius","outerRadius"],t),{offset:r,spacing:l}=this.options,h=(s+n)/2,c=(o+a+l+r)/2;return{x:e+Math.cos(h)*c,y:i+Math.sin(h)*c}}tooltipPosition(t){return this.getCenterPoint(t)}draw(t){const{options:e,circumference:i}=this,s=(e.offset||0)/4,n=(e.spacing||0)/2,o=e.circular;if(this.pixelMargin="inner"===e.borderAlign?.33:0,this.fullCircles=i>O?Math.floor(i/O):0,0===i||this.innerRadius<0||this.outerRadius<0)return;t.save();const a=(this.startAngle+this.endAngle)/2;t.translate(Math.cos(a)*s,Math.sin(a)*s);const r=s*(1-Math.sin(Math.min(C,i||0)));t.fillStyle=e.backgroundColor,t.strokeStyle=e.borderColor,function(t,e,i,s,n){const{fullCircles:o,startAngle:a,circumference:r}=e;let l=e.endAngle;if(o){qn(t,e,i,s,l,n);for(let e=0;e<o;++e)t.fill();isNaN(r)||(l=a+(r%O||O))}qn(t,e,i,s,l,n),t.fill()}(t,this,r,n,o),Kn(t,this,r,n,o),t.restore()}},BarElement:class extends Hs{static id="bar";static defaults={borderSkipped:"start",borderWidth:0,borderRadius:0,inflateAmount:"auto",pointStyle:void 0};static defaultRoutes={backgroundColor:"backgroundColor",borderColor:"borderColor"};constructor(t){super(),this.options=void 0,this.horizontal=void 0,this.base=void 0,this.width=void 0,this.height=void 0,this.inflateAmount=void 0,t&&Object.assign(this,t)}draw(t){const{inflateAmount:e,options:{borderColor:i,backgroundColor:s}}=this,{inner:n,outer:o}=lo(this),a=(r=o.radius).topLeft||r.topRight||r.bottomLeft||r.bottomRight?He:co;var r;t.save(),o.w===n.w&&o.h===n.h||(t.beginPath(),a(t,uo(o,e,n)),t.clip(),a(t,uo(n,-e,o)),t.fillStyle=i,t.fill("evenodd")),t.beginPath(),a(t,uo(n,e)),t.fillStyle=s,t.fill(),t.restore()}inRange(t,e,i){return ho(this,t,e,i)}inXRange(t,e){return ho(this,t,null,e)}inYRange(t,e){return ho(this,null,t,e)}getCenterPoint(t){const{x:e,y:i,base:s,horizontal:n}=this.getProps(["x","y","base","horizontal"],t);return{x:n?(e+s)/2:e,y:n?i:(i+s)/2}}getRange(t){return"x"===t?this.width/2:this.height/2}},LineElement:no,PointElement:class extends Hs{static id="point";parsed;skip;stop;static defaults={borderWidth:1,hitRadius:1,hoverBorderWidth:1,hoverRadius:4,pointStyle:"circle",radius:3,rotation:0};static defaultRoutes={backgroundColor:"backgroundColor",borderColor:"borderColor"};constructor(t){super(),this.options=void 0,this.parsed=void 0,this.skip=void 0,this.stop=void 0,t&&Object.assign(this,t)}inRange(t,e,i){const s=this.options,{x:n,y:o}=this.getProps(["x","y"],i);return Math.pow(t-n,2)+Math.pow(e-o,2)<Math.pow(s.hitRadius+s.radius,2)}inXRange(t,e){return oo(this,t,"x",e)}inYRange(t,e){return oo(this,t,"y",e)}getCenterPoint(t){const{x:e,y:i}=this.getProps(["x","y"],t);return{x:e,y:i}}size(t){let e=(t=t||this.options||{}).radius||0;e=Math.max(e,e&&t.hoverRadius||0);return 2*(e+(e&&t.borderWidth||0))}draw(t,e){const i=this.options;this.skip||i.radius<.1||!Re(this,e,this.size(i)/2)||(t.strokeStyle=i.borderColor,t.lineWidth=i.borderWidth,t.fillStyle=i.backgroundColor,Le(t,i,this.x,this.y))}getRange(){const t=this.options||{};return t.radius+t.hitRadius}}});function go(t,e,i,s){const n=t.indexOf(e);if(-1===n)return((t,e,i,s)=>("string"==typeof e?(i=t.push(e)-1,s.unshift({index:i,label:e})):isNaN(e)&&(i=null),i))(t,e,i,s);return n!==t.lastIndexOf(e)?i:n}function po(t){const e=this.getLabels();return t>=0&&t<e.length?e[t]:t}function mo(t,e,{horizontal:i,minRotation:s}){const n=$(s),o=(i?Math.sin(n):Math.cos(n))||.001,a=.75*e*(""+t).length;return Math.min(e/o,a)}class xo extends Js{constructor(t){super(t),this.start=void 0,this.end=void 0,this._startValue=void 0,this._endValue=void 0,this._valueRange=0}parse(t,e){return s(t)||("number"==typeof t||t instanceof Number)&&!isFinite(+t)?null:+t}handleTickRangeOptions(){const{beginAtZero:t}=this.options,{minDefined:e,maxDefined:i}=this.getUserBounds();let{min:s,max:n}=this;const o=t=>s=e?s:t,a=t=>n=i?n:t;if(t){const t=F(s),e=F(n);t<0&&e<0?a(0):t>0&&e>0&&o(0)}if(s===n){let e=0===n?1:Math.abs(.05*n);a(n+e),t||o(s-e)}this.min=s,this.max=n}getTickLimit(){const t=this.options.ticks;let e,{maxTicksLimit:i,stepSize:s}=t;return s?(e=Math.ceil(this.max/s)-Math.floor(this.min/s)+1,e>1e3&&(console.warn(`scales.${this.id}.ticks.stepSize: ${s} would result generating up to ${e} ticks. Limiting to 1000.`),e=1e3)):(e=this.computeTickLimit(),i=i||11),i&&(e=Math.min(i,e)),e}computeTickLimit(){return Number.POSITIVE_INFINITY}buildTicks(){const t=this.options,e=t.ticks;let i=this.getTickLimit();i=Math.max(2,i);const n=function(t,e){const i=[],{bounds:n,step:o,min:a,max:r,precision:l,count:h,maxTicks:c,maxDigits:d,includeBounds:u}=t,f=o||1,g=c-1,{min:p,max:m}=e,x=!s(a),b=!s(r),_=!s(h),y=(m-p)/(d+1);let v,M,w,k,S=B((m-p)/g/f)*f;if(S<1e-14&&!x&&!b)return[{value:p},{value:m}];k=Math.ceil(m/S)-Math.floor(p/S),k>g&&(S=B(k*S/g/f)*f),s(l)||(v=Math.pow(10,l),S=Math.ceil(S*v)/v),"ticks"===n?(M=Math.floor(p/S)*S,w=Math.ceil(m/S)*S):(M=p,w=m),x&&b&&o&&H((r-a)/o,S/1e3)?(k=Math.round(Math.min((r-a)/S,c)),S=(r-a)/k,M=a,w=r):_?(M=x?a:M,w=b?r:w,k=h-1,S=(w-M)/k):(k=(w-M)/S,k=V(k,Math.round(k),S/1e3)?Math.round(k):Math.ceil(k));const P=Math.max(U(S),U(M));v=Math.pow(10,s(l)?P:l),M=Math.round(M*v)/v,w=Math.round(w*v)/v;let D=0;for(x&&(u&&M!==a?(i.push({value:a}),M<a&&D++,V(Math.round((M+D*S)*v)/v,a,mo(a,y,t))&&D++):M<a&&D++);D<k;++D){const t=Math.round((M+D*S)*v)/v;if(b&&t>r)break;i.push({value:t})}return b&&u&&w!==r?i.length&&V(i[i.length-1].value,r,mo(r,y,t))?i[i.length-1].value=r:i.push({value:r}):b&&w!==r||i.push({value:w}),i}({maxTicks:i,bounds:t.bounds,min:t.min,max:t.max,precision:e.precision,step:e.stepSize,count:e.count,maxDigits:this._maxDigits(),horizontal:this.isHorizontal(),minRotation:e.minRotation||0,includeBounds:!1!==e.includeBounds},this._range||this);return"ticks"===t.bounds&&j(n,this,"value"),t.reverse?(n.reverse(),this.start=this.max,this.end=this.min):(this.start=this.min,this.end=this.max),n}configure(){const t=this.ticks;let e=this.min,i=this.max;if(super.configure(),this.options.offset&&t.length){const s=(i-e)/Math.max(t.length-1,1)/2;e-=s,i+=s}this._startValue=e,this._endValue=i,this._valueRange=i-e}getLabelForValue(t){return ne(t,this.chart.options.locale,this.options.ticks.format)}}class bo extends xo{static id="linear";static defaults={ticks:{callback:ae.formatters.numeric}};determineDataLimits(){const{min:t,max:e}=this.getMinMax(!0);this.min=a(t)?t:0,this.max=a(e)?e:1,this.handleTickRangeOptions()}computeTickLimit(){const t=this.isHorizontal(),e=t?this.width:this.height,i=$(this.options.ticks.minRotation),s=(t?Math.sin(i):Math.cos(i))||.001,n=this._resolveTickFontOptions(0);return Math.ceil(e/Math.min(40,n.lineHeight/s))}getPixelForValue(t){return null===t?NaN:this.getPixelForDecimal((t-this._startValue)/this._valueRange)}getValueForPixel(t){return this._startValue+this.getDecimalForPixel(t)*this._valueRange}}const _o=t=>Math.floor(z(t)),yo=(t,e)=>Math.pow(10,_o(t)+e);function vo(t){return 1===t/Math.pow(10,_o(t))}function Mo(t,e,i){const s=Math.pow(10,i),n=Math.floor(t/s);return Math.ceil(e/s)-n}function wo(t,{min:e,max:i}){e=r(t.min,e);const s=[],n=_o(e);let o=function(t,e){let i=_o(e-t);for(;Mo(t,e,i)>10;)i++;for(;Mo(t,e,i)<10;)i--;return Math.min(i,_o(t))}(e,i),a=o<0?Math.pow(10,Math.abs(o)):1;const l=Math.pow(10,o),h=n>o?Math.pow(10,n):0,c=Math.round((e-h)*a)/a,d=Math.floor((e-h)/l/10)*l*10;let u=Math.floor((c-d)/Math.pow(10,o)),f=r(t.min,Math.round((h+d+u*Math.pow(10,o))*a)/a);for(;f<i;)s.push({value:f,major:vo(f),significand:u}),u>=10?u=u<15?15:20:u++,u>=20&&(o++,u=2,a=o>=0?1:a),f=Math.round((h+d+u*Math.pow(10,o))*a)/a;const g=r(t.max,f);return s.push({value:g,major:vo(g),significand:u}),s}class ko extends Js{static id="logarithmic";static defaults={ticks:{callback:ae.formatters.logarithmic,major:{enabled:!0}}};constructor(t){super(t),this.start=void 0,this.end=void 0,this._startValue=void 0,this._valueRange=0}parse(t,e){const i=xo.prototype.parse.apply(this,[t,e]);if(0!==i)return a(i)&&i>0?i:null;this._zero=!0}determineDataLimits(){const{min:t,max:e}=this.getMinMax(!0);this.min=a(t)?Math.max(0,t):null,this.max=a(e)?Math.max(0,e):null,this.options.beginAtZero&&(this._zero=!0),this._zero&&this.min!==this._suggestedMin&&!a(this._userMin)&&(this.min=t===yo(this.min,0)?yo(this.min,-1):yo(this.min,0)),this.handleTickRangeOptions()}handleTickRangeOptions(){const{minDefined:t,maxDefined:e}=this.getUserBounds();let i=this.min,s=this.max;const n=e=>i=t?i:e,o=t=>s=e?s:t;i===s&&(i<=0?(n(1),o(10)):(n(yo(i,-1)),o(yo(s,1)))),i<=0&&n(yo(s,-1)),s<=0&&o(yo(i,1)),this.min=i,this.max=s}buildTicks(){const t=this.options,e=wo({min:this._userMin,max:this._userMax},this);return"ticks"===t.bounds&&j(e,this,"value"),t.reverse?(e.reverse(),this.start=this.max,this.end=this.min):(this.start=this.min,this.end=this.max),e}getLabelForValue(t){return void 0===t?"0":ne(t,this.chart.options.locale,this.options.ticks.format)}configure(){const t=this.min;super.configure(),this._startValue=z(t),this._valueRange=z(this.max)-z(t)}getPixelForValue(t){return void 0!==t&&0!==t||(t=this.min),null===t||isNaN(t)?NaN:this.getPixelForDecimal(t===this.min?0:(z(t)-this._startValue)/this._valueRange)}getValueForPixel(t){const e=this.getDecimalForPixel(t);return Math.pow(10,this._startValue+e*this._valueRange)}}function So(t){const e=t.ticks;if(e.display&&t.display){const t=ki(e.backdropPadding);return l(e.font&&e.font.size,ue.font.size)+t.height}return 0}function Po(t,e,i,s,n){return t===s||t===n?{start:e-i/2,end:e+i/2}:t<s||t>n?{start:e-i,end:e}:{start:e,end:e+i}}function Do(t){const e={l:t.left+t._padding.left,r:t.right-t._padding.right,t:t.top+t._padding.top,b:t.bottom-t._padding.bottom},i=Object.assign({},e),s=[],o=[],a=t._pointLabels.length,r=t.options.pointLabels,l=r.centerPointLabels?C/a:0;for(let u=0;u<a;u++){const a=r.setContext(t.getPointLabelContext(u));o[u]=a.padding;const f=t.getPointPosition(u,t.drawingArea+o[u],l),g=Si(a.font),p=(h=t.ctx,c=g,d=n(d=t._pointLabels[u])?d:[d],{w:Oe(h,c.string,d),h:d.length*c.lineHeight});s[u]=p;const m=G(t.getIndexAngle(u)+l),x=Math.round(Y(m));Co(i,e,m,Po(x,f.x,p.w,0,180),Po(x,f.y,p.h,90,270))}var h,c,d;t.setCenterPoint(e.l-i.l,i.r-e.r,e.t-i.t,i.b-e.b),t._pointLabelItems=function(t,e,i){const s=[],n=t._pointLabels.length,o=t.options,{centerPointLabels:a,display:r}=o.pointLabels,l={extra:So(o)/2,additionalAngle:a?C/n:0};let h;for(let o=0;o<n;o++){l.padding=i[o],l.size=e[o];const n=Oo(t,o,l);s.push(n),"auto"===r&&(n.visible=Ao(n,h),n.visible&&(h=n))}return s}(t,s,o)}function Co(t,e,i,s,n){const o=Math.abs(Math.sin(i)),a=Math.abs(Math.cos(i));let r=0,l=0;s.start<e.l?(r=(e.l-s.start)/o,t.l=Math.min(t.l,e.l-r)):s.end>e.r&&(r=(s.end-e.r)/o,t.r=Math.max(t.r,e.r+r)),n.start<e.t?(l=(e.t-n.start)/a,t.t=Math.min(t.t,e.t-l)):n.end>e.b&&(l=(n.end-e.b)/a,t.b=Math.max(t.b,e.b+l))}function Oo(t,e,i){const s=t.drawingArea,{extra:n,additionalAngle:o,padding:a,size:r}=i,l=t.getPointPosition(e,s+n+a,o),h=Math.round(Y(G(l.angle+E))),c=function(t,e,i){90===i||270===i?t-=e/2:(i>270||i<90)&&(t-=e);return t}(l.y,r.h,h),d=function(t){if(0===t||180===t)return"center";if(t<180)return"left";return"right"}(h),u=function(t,e,i){"right"===i?t-=e:"center"===i&&(t-=e/2);return t}(l.x,r.w,d);return{visible:!0,x:l.x,y:c,textAlign:d,left:u,top:c,right:u+r.w,bottom:c+r.h}}function Ao(t,e){if(!e)return!0;const{left:i,top:s,right:n,bottom:o}=t;return!(Re({x:i,y:s},e)||Re({x:i,y:o},e)||Re({x:n,y:s},e)||Re({x:n,y:o},e))}function To(t,e,i){const{left:n,top:o,right:a,bottom:r}=i,{backdropColor:l}=e;if(!s(l)){const i=wi(e.borderRadius),s=ki(e.backdropPadding);t.fillStyle=l;const h=n-s.left,c=o-s.top,d=a-n+s.width,u=r-o+s.height;Object.values(i).some((t=>0!==t))?(t.beginPath(),He(t,{x:h,y:c,w:d,h:u,radius:i}),t.fill()):t.fillRect(h,c,d,u)}}function Lo(t,e,i,s){const{ctx:n}=t;if(i)n.arc(t.xCenter,t.yCenter,e,0,O);else{let i=t.getPointPosition(0,e);n.moveTo(i.x,i.y);for(let o=1;o<s;o++)i=t.getPointPosition(o,e),n.lineTo(i.x,i.y)}}class Eo extends xo{static id="radialLinear";static defaults={display:!0,animate:!0,position:"chartArea",angleLines:{display:!0,lineWidth:1,borderDash:[],borderDashOffset:0},grid:{circular:!1},startAngle:0,ticks:{showLabelBackdrop:!0,callback:ae.formatters.numeric},pointLabels:{backdropColor:void 0,backdropPadding:2,display:!0,font:{size:10},callback:t=>t,padding:5,centerPointLabels:!1}};static defaultRoutes={"angleLines.color":"borderColor","pointLabels.color":"color","ticks.color":"color"};static descriptors={angleLines:{_fallback:"grid"}};constructor(t){super(t),this.xCenter=void 0,this.yCenter=void 0,this.drawingArea=void 0,this._pointLabels=[],this._pointLabelItems=[]}setDimensions(){const t=this._padding=ki(So(this.options)/2),e=this.width=this.maxWidth-t.width,i=this.height=this.maxHeight-t.height;this.xCenter=Math.floor(this.left+e/2+t.left),this.yCenter=Math.floor(this.top+i/2+t.top),this.drawingArea=Math.floor(Math.min(e,i)/2)}determineDataLimits(){const{min:t,max:e}=this.getMinMax(!1);this.min=a(t)&&!isNaN(t)?t:0,this.max=a(e)&&!isNaN(e)?e:0,this.handleTickRangeOptions()}computeTickLimit(){return Math.ceil(this.drawingArea/So(this.options))}generateTickLabels(t){xo.prototype.generateTickLabels.call(this,t),this._pointLabels=this.getLabels().map(((t,e)=>{const i=d(this.options.pointLabels.callback,[t,e],this);return i||0===i?i:""})).filter(((t,e)=>this.chart.getDataVisibility(e)))}fit(){const t=this.options;t.display&&t.pointLabels.display?Do(this):this.setCenterPoint(0,0,0,0)}setCenterPoint(t,e,i,s){this.xCenter+=Math.floor((t-e)/2),this.yCenter+=Math.floor((i-s)/2),this.drawingArea-=Math.min(this.drawingArea/2,Math.max(t,e,i,s))}getIndexAngle(t){return G(t*(O/(this._pointLabels.length||1))+$(this.options.startAngle||0))}getDistanceFromCenterForValue(t){if(s(t))return NaN;const e=this.drawingArea/(this.max-this.min);return this.options.reverse?(this.max-t)*e:(t-this.min)*e}getValueForDistanceFromCenter(t){if(s(t))return NaN;const e=t/(this.drawingArea/(this.max-this.min));return this.options.reverse?this.max-e:this.min+e}getPointLabelContext(t){const e=this._pointLabels||[];if(t>=0&&t<e.length){const i=e[t];return function(t,e,i){return Ci(t,{label:i,index:e,type:"pointLabel"})}(this.getContext(),t,i)}}getPointPosition(t,e,i=0){const s=this.getIndexAngle(t)-E+i;return{x:Math.cos(s)*e+this.xCenter,y:Math.sin(s)*e+this.yCenter,angle:s}}getPointPositionForValue(t,e){return this.getPointPosition(t,this.getDistanceFromCenterForValue(e))}getBasePosition(t){return this.getPointPositionForValue(t||0,this.getBaseValue())}getPointLabelPosition(t){const{left:e,top:i,right:s,bottom:n}=this._pointLabelItems[t];return{left:e,top:i,right:s,bottom:n}}drawBackground(){const{backgroundColor:t,grid:{circular:e}}=this.options;if(t){const i=this.ctx;i.save(),i.beginPath(),Lo(this,this.getDistanceFromCenterForValue(this._endValue),e,this._pointLabels.length),i.closePath(),i.fillStyle=t,i.fill(),i.restore()}}drawGrid(){const t=this.ctx,e=this.options,{angleLines:i,grid:s,border:n}=e,o=this._pointLabels.length;let a,r,l;if(e.pointLabels.display&&function(t,e){const{ctx:i,options:{pointLabels:s}}=t;for(let n=e-1;n>=0;n--){const e=t._pointLabelItems[n];if(!e.visible)continue;const o=s.setContext(t.getPointLabelContext(n));To(i,o,e);const a=Si(o.font),{x:r,y:l,textAlign:h}=e;Ne(i,t._pointLabels[n],r,l+a.lineHeight/2,a,{color:o.color,textAlign:h,textBaseline:"middle"})}}(this,o),s.display&&this.ticks.forEach(((t,e)=>{if(0!==e||0===e&&this.min<0){r=this.getDistanceFromCenterForValue(t.value);const i=this.getContext(e),a=s.setContext(i),l=n.setContext(i);!function(t,e,i,s,n){const o=t.ctx,a=e.circular,{color:r,lineWidth:l}=e;!a&&!s||!r||!l||i<0||(o.save(),o.strokeStyle=r,o.lineWidth=l,o.setLineDash(n.dash),o.lineDashOffset=n.dashOffset,o.beginPath(),Lo(t,i,a,s),o.closePath(),o.stroke(),o.restore())}(this,a,r,o,l)}})),i.display){for(t.save(),a=o-1;a>=0;a--){const s=i.setContext(this.getPointLabelContext(a)),{color:n,lineWidth:o}=s;o&&n&&(t.lineWidth=o,t.strokeStyle=n,t.setLineDash(s.borderDash),t.lineDashOffset=s.borderDashOffset,r=this.getDistanceFromCenterForValue(e.reverse?this.min:this.max),l=this.getPointPosition(a,r),t.beginPath(),t.moveTo(this.xCenter,this.yCenter),t.lineTo(l.x,l.y),t.stroke())}t.restore()}}drawBorder(){}drawLabels(){const t=this.ctx,e=this.options,i=e.ticks;if(!i.display)return;const s=this.getIndexAngle(0);let n,o;t.save(),t.translate(this.xCenter,this.yCenter),t.rotate(s),t.textAlign="center",t.textBaseline="middle",this.ticks.forEach(((s,a)=>{if(0===a&&this.min>=0&&!e.reverse)return;const r=i.setContext(this.getContext(a)),l=Si(r.font);if(n=this.getDistanceFromCenterForValue(this.ticks[a].value),r.showLabelBackdrop){t.font=l.string,o=t.measureText(s.label).width,t.fillStyle=r.backdropColor;const e=ki(r.backdropPadding);t.fillRect(-o/2-e.left,-n-l.size/2-e.top,o+e.width,l.size+e.height)}Ne(t,s.label,0,-n,l,{color:r.color,strokeColor:r.textStrokeColor,strokeWidth:r.textStrokeWidth})})),t.restore()}drawTitle(){}}const Ro={millisecond:{common:!0,size:1,steps:1e3},second:{common:!0,size:1e3,steps:60},minute:{common:!0,size:6e4,steps:60},hour:{common:!0,size:36e5,steps:24},day:{common:!0,size:864e5,steps:30},week:{common:!1,size:6048e5,steps:4},month:{common:!0,size:2628e6,steps:12},quarter:{common:!1,size:7884e6,steps:4},year:{common:!0,size:3154e7}},Io=Object.keys(Ro);function zo(t,e){return t-e}function Fo(t,e){if(s(e))return null;const i=t._adapter,{parser:n,round:o,isoWeekday:r}=t._parseOpts;let l=e;return"function"==typeof n&&(l=n(l)),a(l)||(l="string"==typeof n?i.parse(l,n):i.parse(l)),null===l?null:(o&&(l="week"!==o||!N(r)&&!0!==r?i.startOf(l,o):i.startOf(l,"isoWeek",r)),+l)}function Vo(t,e,i,s){const n=Io.length;for(let o=Io.indexOf(t);o<n-1;++o){const t=Ro[Io[o]],n=t.steps?t.steps:Number.MAX_SAFE_INTEGER;if(t.common&&Math.ceil((i-e)/(n*t.size))<=s)return Io[o]}return Io[n-1]}function Bo(t,e,i){if(i){if(i.length){const{lo:s,hi:n}=et(i,e);t[i[s]>=e?i[s]:i[n]]=!0}}else t[e]=!0}function Wo(t,e,i){const s=[],n={},o=e.length;let a,r;for(a=0;a<o;++a)r=e[a],n[r]=a,s.push({value:r,major:!1});return 0!==o&&i?function(t,e,i,s){const n=t._adapter,o=+n.startOf(e[0].value,s),a=e[e.length-1].value;let r,l;for(r=o;r<=a;r=+n.add(r,1,s))l=i[r],l>=0&&(e[l].major=!0);return e}(t,s,n,i):s}class No extends Js{static id="time";static defaults={bounds:"data",adapters:{},time:{parser:!1,unit:!1,round:!1,isoWeekday:!1,minUnit:"millisecond",displayFormats:{}},ticks:{source:"auto",callback:!1,major:{enabled:!1}}};constructor(t){super(t),this._cache={data:[],labels:[],all:[]},this._unit="day",this._majorUnit=void 0,this._offsets={},this._normalized=!1,this._parseOpts=void 0}init(t,e={}){const i=t.time||(t.time={}),s=this._adapter=new Rn._date(t.adapters.date);s.init(e),b(i.displayFormats,s.formats()),this._parseOpts={parser:i.parser,round:i.round,isoWeekday:i.isoWeekday},super.init(t),this._normalized=e.normalized}parse(t,e){return void 0===t?null:Fo(this,t)}beforeLayout(){super.beforeLayout(),this._cache={data:[],labels:[],all:[]}}determineDataLimits(){const t=this.options,e=this._adapter,i=t.time.unit||"day";let{min:s,max:n,minDefined:o,maxDefined:r}=this.getUserBounds();function l(t){o||isNaN(t.min)||(s=Math.min(s,t.min)),r||isNaN(t.max)||(n=Math.max(n,t.max))}o&&r||(l(this._getLabelBounds()),"ticks"===t.bounds&&"labels"===t.ticks.source||l(this.getMinMax(!1))),s=a(s)&&!isNaN(s)?s:+e.startOf(Date.now(),i),n=a(n)&&!isNaN(n)?n:+e.endOf(Date.now(),i)+1,this.min=Math.min(s,n-1),this.max=Math.max(s+1,n)}_getLabelBounds(){const t=this.getLabelTimestamps();let e=Number.POSITIVE_INFINITY,i=Number.NEGATIVE_INFINITY;return t.length&&(e=t[0],i=t[t.length-1]),{min:e,max:i}}buildTicks(){const t=this.options,e=t.time,i=t.ticks,s="labels"===i.source?this.getLabelTimestamps():this._generate();"ticks"===t.bounds&&s.length&&(this.min=this._userMin||s[0],this.max=this._userMax||s[s.length-1]);const n=this.min,o=nt(s,n,this.max);return this._unit=e.unit||(i.autoSkip?Vo(e.minUnit,this.min,this.max,this._getLabelCapacity(n)):function(t,e,i,s,n){for(let o=Io.length-1;o>=Io.indexOf(i);o--){const i=Io[o];if(Ro[i].common&&t._adapter.diff(n,s,i)>=e-1)return i}return Io[i?Io.indexOf(i):0]}(this,o.length,e.minUnit,this.min,this.max)),this._majorUnit=i.major.enabled&&"year"!==this._unit?function(t){for(let e=Io.indexOf(t)+1,i=Io.length;e<i;++e)if(Ro[Io[e]].common)return Io[e]}(this._unit):void 0,this.initOffsets(s),t.reverse&&o.reverse(),Wo(this,o,this._majorUnit)}afterAutoSkip(){this.options.offsetAfterAutoskip&&this.initOffsets(this.ticks.map((t=>+t.value)))}initOffsets(t=[]){let e,i,s=0,n=0;this.options.offset&&t.length&&(e=this.getDecimalForValue(t[0]),s=1===t.length?1-e:(this.getDecimalForValue(t[1])-e)/2,i=this.getDecimalForValue(t[t.length-1]),n=1===t.length?i:(i-this.getDecimalForValue(t[t.length-2]))/2);const o=t.length<3?.5:.25;s=J(s,0,o),n=J(n,0,o),this._offsets={start:s,end:n,factor:1/(s+1+n)}}_generate(){const t=this._adapter,e=this.min,i=this.max,s=this.options,n=s.time,o=n.unit||Vo(n.minUnit,e,i,this._getLabelCapacity(e)),a=l(s.ticks.stepSize,1),r="week"===o&&n.isoWeekday,h=N(r)||!0===r,c={};let d,u,f=e;if(h&&(f=+t.startOf(f,"isoWeek",r)),f=+t.startOf(f,h?"day":o),t.diff(i,e,o)>1e5*a)throw new Error(e+" and "+i+" are too far apart with stepSize of "+a+" "+o);const g="data"===s.ticks.source&&this.getDataTimestamps();for(d=f,u=0;d<i;d=+t.add(d,a,o),u++)Bo(c,d,g);return d!==i&&"ticks"!==s.bounds&&1!==u||Bo(c,d,g),Object.keys(c).sort(zo).map((t=>+t))}getLabelForValue(t){const e=this._adapter,i=this.options.time;return i.tooltipFormat?e.format(t,i.tooltipFormat):e.format(t,i.displayFormats.datetime)}format(t,e){const i=this.options.time.displayFormats,s=this._unit,n=e||i[s];return this._adapter.format(t,n)}_tickFormatFunction(t,e,i,s){const n=this.options,o=n.ticks.callback;if(o)return d(o,[t,e,i],this);const a=n.time.displayFormats,r=this._unit,l=this._majorUnit,h=r&&a[r],c=l&&a[l],u=i[e],f=l&&c&&u&&u.major;return this._adapter.format(t,s||(f?c:h))}generateTickLabels(t){let e,i,s;for(e=0,i=t.length;e<i;++e)s=t[e],s.label=this._tickFormatFunction(s.value,e,t)}getDecimalForValue(t){return null===t?NaN:(t-this.min)/(this.max-this.min)}getPixelForValue(t){const e=this._offsets,i=this.getDecimalForValue(t);return this.getPixelForDecimal((e.start+i)*e.factor)}getValueForPixel(t){const e=this._offsets,i=this.getDecimalForPixel(t)/e.factor-e.end;return this.min+i*(this.max-this.min)}_getLabelSize(t){const e=this.options.ticks,i=this.ctx.measureText(t).width,s=$(this.isHorizontal()?e.maxRotation:e.minRotation),n=Math.cos(s),o=Math.sin(s),a=this._resolveTickFontOptions(0).size;return{w:i*n+a*o,h:i*o+a*n}}_getLabelCapacity(t){const e=this.options.time,i=e.displayFormats,s=i[e.unit]||i.millisecond,n=this._tickFormatFunction(t,0,Wo(this,[t],this._majorUnit),s),o=this._getLabelSize(n),a=Math.floor(this.isHorizontal()?this.width/o.w:this.height/o.h)-1;return a>0?a:1}getDataTimestamps(){let t,e,i=this._cache.data||[];if(i.length)return i;const s=this.getMatchingVisibleMetas();if(this._normalized&&s.length)return this._cache.data=s[0].controller.getAllParsedValues(this);for(t=0,e=s.length;t<e;++t)i=i.concat(s[t].controller.getAllParsedValues(this));return this._cache.data=this.normalize(i)}getLabelTimestamps(){const t=this._cache.labels||[];let e,i;if(t.length)return t;const s=this.getLabels();for(e=0,i=s.length;e<i;++e)t.push(Fo(this,s[e]));return this._cache.labels=this._normalized?t:this.normalize(t)}normalize(t){return lt(t.sort(zo))}}function Ho(t,e,i){let s,n,o,a,r=0,l=t.length-1;i?(e>=t[r].pos&&e<=t[l].pos&&({lo:r,hi:l}=it(t,"pos",e)),({pos:s,time:o}=t[r]),({pos:n,time:a}=t[l])):(e>=t[r].time&&e<=t[l].time&&({lo:r,hi:l}=it(t,"time",e)),({time:s,pos:o}=t[r]),({time:n,pos:a}=t[l]));const h=n-s;return h?o+(a-o)*(e-s)/h:o}var jo=Object.freeze({__proto__:null,CategoryScale:class extends Js{static id="category";static defaults={ticks:{callback:po}};constructor(t){super(t),this._startValue=void 0,this._valueRange=0,this._addedLabels=[]}init(t){const e=this._addedLabels;if(e.length){const t=this.getLabels();for(const{index:i,label:s}of e)t[i]===s&&t.splice(i,1);this._addedLabels=[]}super.init(t)}parse(t,e){if(s(t))return null;const i=this.getLabels();return((t,e)=>null===t?null:J(Math.round(t),0,e))(e=isFinite(e)&&i[e]===t?e:go(i,t,l(e,t),this._addedLabels),i.length-1)}determineDataLimits(){const{minDefined:t,maxDefined:e}=this.getUserBounds();let{min:i,max:s}=this.getMinMax(!0);"ticks"===this.options.bounds&&(t||(i=0),e||(s=this.getLabels().length-1)),this.min=i,this.max=s}buildTicks(){const t=this.min,e=this.max,i=this.options.offset,s=[];let n=this.getLabels();n=0===t&&e===n.length-1?n:n.slice(t,e+1),this._valueRange=Math.max(n.length-(i?0:1),1),this._startValue=this.min-(i?.5:0);for(let i=t;i<=e;i++)s.push({value:i});return s}getLabelForValue(t){return po.call(this,t)}configure(){super.configure(),this.isHorizontal()||(this._reversePixels=!this._reversePixels)}getPixelForValue(t){return"number"!=typeof t&&(t=this.parse(t)),null===t?NaN:this.getPixelForDecimal((t-this._startValue)/this._valueRange)}getPixelForTick(t){const e=this.ticks;return t<0||t>e.length-1?null:this.getPixelForValue(e[t].value)}getValueForPixel(t){return Math.round(this._startValue+this.getDecimalForPixel(t)*this._valueRange)}getBasePixel(){return this.bottom}},LinearScale:bo,LogarithmicScale:ko,RadialLinearScale:Eo,TimeScale:No,TimeSeriesScale:class extends No{static id="timeseries";static defaults=No.defaults;constructor(t){super(t),this._table=[],this._minPos=void 0,this._tableRange=void 0}initOffsets(){const t=this._getTimestampsForTable(),e=this._table=this.buildLookupTable(t);this._minPos=Ho(e,this.min),this._tableRange=Ho(e,this.max)-this._minPos,super.initOffsets(t)}buildLookupTable(t){const{min:e,max:i}=this,s=[],n=[];let o,a,r,l,h;for(o=0,a=t.length;o<a;++o)l=t[o],l>=e&&l<=i&&s.push(l);if(s.length<2)return[{time:e,pos:0},{time:i,pos:1}];for(o=0,a=s.length;o<a;++o)h=s[o+1],r=s[o-1],l=s[o],Math.round((h+r)/2)!==l&&n.push({time:l,pos:o/(a-1)});return n}_generate(){const t=this.min,e=this.max;let i=super.getDataTimestamps();return i.includes(t)&&i.length||i.splice(0,0,t),i.includes(e)&&1!==i.length||i.push(e),i.sort(((t,e)=>t-e))}_getTimestampsForTable(){let t=this._cache.all||[];if(t.length)return t;const e=this.getDataTimestamps(),i=this.getLabelTimestamps();return t=e.length&&i.length?this.normalize(e.concat(i)):e.length?e:i,t=this._cache.all=t,t}getDecimalForValue(t){return(Ho(this._table,t)-this._minPos)/this._tableRange}getValueForPixel(t){const e=this._offsets,i=this.getDecimalForPixel(t)/e.factor-e.end;return Ho(this._table,i*this._tableRange+this._minPos,!0)}}});const $o=["rgb(54, 162, 235)","rgb(255, 99, 132)","rgb(255, 159, 64)","rgb(255, 205, 86)","rgb(75, 192, 192)","rgb(153, 102, 255)","rgb(201, 203, 207)"],Yo=$o.map((t=>t.replace("rgb(","rgba(").replace(")",", 0.5)")));function Uo(t){return $o[t%$o.length]}function Xo(t){return Yo[t%Yo.length]}function qo(t){let e=0;return(i,s)=>{const n=t.getDatasetMeta(s).controller;n instanceof jn?e=function(t,e){return t.backgroundColor=t.data.map((()=>Uo(e++))),e}(i,e):n instanceof $n?e=function(t,e){return t.backgroundColor=t.data.map((()=>Xo(e++))),e}(i,e):n&&(e=function(t,e){return t.borderColor=Uo(e),t.backgroundColor=Xo(e),++e}(i,e))}}function Ko(t){let e;for(e in t)if(t[e].borderColor||t[e].backgroundColor)return!0;return!1}var Go={id:"colors",defaults:{enabled:!0,forceOverride:!1},beforeLayout(t,e,i){if(!i.enabled)return;const{data:{datasets:s},options:n}=t.config,{elements:o}=n;if(!i.forceOverride&&(Ko(s)||(a=n)&&(a.borderColor||a.backgroundColor)||o&&Ko(o)))return;var a;const r=qo(t);s.forEach(r)}};function Zo(t){if(t._decimated){const e=t._data;delete t._decimated,delete t._data,Object.defineProperty(t,"data",{configurable:!0,enumerable:!0,writable:!0,value:e})}}function Jo(t){t.data.datasets.forEach((t=>{Zo(t)}))}var Qo={id:"decimation",defaults:{algorithm:"min-max",enabled:!1},beforeElementsUpdate:(t,e,i)=>{if(!i.enabled)return void Jo(t);const n=t.width;t.data.datasets.forEach(((e,o)=>{const{_data:a,indexAxis:r}=e,l=t.getDatasetMeta(o),h=a||e.data;if("y"===Pi([r,t.options.indexAxis]))return;if(!l.controller.supportsDecimation)return;const c=t.scales[l.xAxisID];if("linear"!==c.type&&"time"!==c.type)return;if(t.options.parsing)return;let{start:d,count:u}=function(t,e){const i=e.length;let s,n=0;const{iScale:o}=t,{min:a,max:r,minDefined:l,maxDefined:h}=o.getUserBounds();return l&&(n=J(it(e,o.axis,a).lo,0,i-1)),s=h?J(it(e,o.axis,r).hi+1,n,i)-n:i-n,{start:n,count:s}}(l,h);if(u<=(i.threshold||4*n))return void Zo(e);let f;switch(s(a)&&(e._data=h,delete e.data,Object.defineProperty(e,"data",{configurable:!0,enumerable:!0,get:function(){return this._decimated},set:function(t){this._data=t}})),i.algorithm){case"lttb":f=function(t,e,i,s,n){const o=n.samples||s;if(o>=i)return t.slice(e,e+i);const a=[],r=(i-2)/(o-2);let l=0;const h=e+i-1;let c,d,u,f,g,p=e;for(a[l++]=t[p],c=0;c<o-2;c++){let s,n=0,o=0;const h=Math.floor((c+1)*r)+1+e,m=Math.min(Math.floor((c+2)*r)+1,i)+e,x=m-h;for(s=h;s<m;s++)n+=t[s].x,o+=t[s].y;n/=x,o/=x;const b=Math.floor(c*r)+1+e,_=Math.min(Math.floor((c+1)*r)+1,i)+e,{x:y,y:v}=t[p];for(u=f=-1,s=b;s<_;s++)f=.5*Math.abs((y-n)*(t[s].y-v)-(y-t[s].x)*(o-v)),f>u&&(u=f,d=t[s],g=s);a[l++]=d,p=g}return a[l++]=t[h],a}(h,d,u,n,i);break;case"min-max":f=function(t,e,i,n){let o,a,r,l,h,c,d,u,f,g,p=0,m=0;const x=[],b=e+i-1,_=t[e].x,y=t[b].x-_;for(o=e;o<e+i;++o){a=t[o],r=(a.x-_)/y*n,l=a.y;const e=0|r;if(e===h)l<f?(f=l,c=o):l>g&&(g=l,d=o),p=(m*p+a.x)/++m;else{const i=o-1;if(!s(c)&&!s(d)){const e=Math.min(c,d),s=Math.max(c,d);e!==u&&e!==i&&x.push({...t[e],x:p}),s!==u&&s!==i&&x.push({...t[s],x:p})}o>0&&i!==u&&x.push(t[i]),x.push(a),h=e,m=0,f=g=l,c=d=u=o}}return x}(h,d,u,n);break;default:throw new Error(`Unsupported decimation algorithm '${i.algorithm}'`)}e._decimated=f}))},destroy(t){Jo(t)}};function ta(t,e,i,s){if(s)return;let n=e[t],o=i[t];return"angle"===t&&(n=G(n),o=G(o)),{property:t,start:n,end:o}}function ea(t,e,i){for(;e>t;e--){const t=i[e];if(!isNaN(t.x)&&!isNaN(t.y))break}return e}function ia(t,e,i,s){return t&&e?s(t[i],e[i]):t?t[i]:e?e[i]:0}function sa(t,e){let i=[],s=!1;return n(t)?(s=!0,i=t):i=function(t,e){const{x:i=null,y:s=null}=t||{},n=e.points,o=[];return e.segments.forEach((({start:t,end:e})=>{e=ea(t,e,n);const a=n[t],r=n[e];null!==s?(o.push({x:a.x,y:s}),o.push({x:r.x,y:s})):null!==i&&(o.push({x:i,y:a.y}),o.push({x:i,y:r.y}))})),o}(t,e),i.length?new no({points:i,options:{tension:0},_loop:s,_fullLoop:s}):null}function na(t){return t&&!1!==t.fill}function oa(t,e,i){let s=t[e].fill;const n=[e];let o;if(!i)return s;for(;!1!==s&&-1===n.indexOf(s);){if(!a(s))return s;if(o=t[s],!o)return!1;if(o.visible)return s;n.push(s),s=o.fill}return!1}function aa(t,e,i){const s=function(t){const e=t.options,i=e.fill;let s=l(i&&i.target,i);void 0===s&&(s=!!e.backgroundColor);if(!1===s||null===s)return!1;if(!0===s)return"origin";return s}(t);if(o(s))return!isNaN(s.value)&&s;let n=parseFloat(s);return a(n)&&Math.floor(n)===n?function(t,e,i,s){"-"!==t&&"+"!==t||(i=e+i);if(i===e||i<0||i>=s)return!1;return i}(s[0],e,n,i):["origin","start","end","stack","shape"].indexOf(s)>=0&&s}function ra(t,e,i){const s=[];for(let n=0;n<i.length;n++){const o=i[n],{first:a,last:r,point:l}=la(o,e,"x");if(!(!l||a&&r))if(a)s.unshift(l);else if(t.push(l),!r)break}t.push(...s)}function la(t,e,i){const s=t.interpolate(e,i);if(!s)return{};const n=s[i],o=t.segments,a=t.points;let r=!1,l=!1;for(let t=0;t<o.length;t++){const e=o[t],s=a[e.start][i],h=a[e.end][i];if(tt(n,s,h)){r=n===s,l=n===h;break}}return{first:r,last:l,point:s}}class ha{constructor(t){this.x=t.x,this.y=t.y,this.radius=t.radius}pathSegment(t,e,i){const{x:s,y:n,radius:o}=this;return e=e||{start:0,end:O},t.arc(s,n,o,e.end,e.start,!0),!i.bounds}interpolate(t){const{x:e,y:i,radius:s}=this,n=t.angle;return{x:e+Math.cos(n)*s,y:i+Math.sin(n)*s,angle:n}}}function ca(t){const{chart:e,fill:i,line:s}=t;if(a(i))return function(t,e){const i=t.getDatasetMeta(e),s=i&&t.isDatasetVisible(e);return s?i.dataset:null}(e,i);if("stack"===i)return function(t){const{scale:e,index:i,line:s}=t,n=[],o=s.segments,a=s.points,r=function(t,e){const i=[],s=t.getMatchingVisibleMetas("line");for(let t=0;t<s.length;t++){const n=s[t];if(n.index===e)break;n.hidden||i.unshift(n.dataset)}return i}(e,i);r.push(sa({x:null,y:e.bottom},s));for(let t=0;t<o.length;t++){const e=o[t];for(let t=e.start;t<=e.end;t++)ra(n,a[t],r)}return new no({points:n,options:{}})}(t);if("shape"===i)return!0;const n=function(t){const e=t.scale||{};if(e.getPointPositionForValue)return function(t){const{scale:e,fill:i}=t,s=e.options,n=e.getLabels().length,a=s.reverse?e.max:e.min,r=function(t,e,i){let s;return s="start"===t?i:"end"===t?e.options.reverse?e.min:e.max:o(t)?t.value:e.getBaseValue(),s}(i,e,a),l=[];if(s.grid.circular){const t=e.getPointPositionForValue(0,a);return new ha({x:t.x,y:t.y,radius:e.getDistanceFromCenterForValue(r)})}for(let t=0;t<n;++t)l.push(e.getPointPositionForValue(t,r));return l}(t);return function(t){const{scale:e={},fill:i}=t,s=function(t,e){let i=null;return"start"===t?i=e.bottom:"end"===t?i=e.top:o(t)?i=e.getPixelForValue(t.value):e.getBasePixel&&(i=e.getBasePixel()),i}(i,e);if(a(s)){const t=e.isHorizontal();return{x:t?s:null,y:t?null:s}}return null}(t)}(t);return n instanceof ha?n:sa(n,s)}function da(t,e,i){const s=ca(e),{line:n,scale:o,axis:a}=e,r=n.options,l=r.fill,h=r.backgroundColor,{above:c=h,below:d=h}=l||{};s&&n.points.length&&(Ie(t,i),function(t,e){const{line:i,target:s,above:n,below:o,area:a,scale:r}=e,l=i._loop?"angle":e.axis;t.save(),"x"===l&&o!==n&&(ua(t,s,a.top),fa(t,{line:i,target:s,color:n,scale:r,property:l}),t.restore(),t.save(),ua(t,s,a.bottom));fa(t,{line:i,target:s,color:o,scale:r,property:l}),t.restore()}(t,{line:n,target:s,above:c,below:d,area:i,scale:o,axis:a}),ze(t))}function ua(t,e,i){const{segments:s,points:n}=e;let o=!0,a=!1;t.beginPath();for(const r of s){const{start:s,end:l}=r,h=n[s],c=n[ea(s,l,n)];o?(t.moveTo(h.x,h.y),o=!1):(t.lineTo(h.x,i),t.lineTo(h.x,h.y)),a=!!e.pathSegment(t,r,{move:a}),a?t.closePath():t.lineTo(c.x,i)}t.lineTo(e.first().x,i),t.closePath(),t.clip()}function fa(t,e){const{line:i,target:s,property:n,color:o,scale:a}=e,r=function(t,e,i){const s=t.segments,n=t.points,o=e.points,a=[];for(const t of s){let{start:s,end:r}=t;r=ea(s,r,n);const l=ta(i,n[s],n[r],t.loop);if(!e.segments){a.push({source:t,target:l,start:n[s],end:n[r]});continue}const h=Ii(e,l);for(const e of h){const s=ta(i,o[e.start],o[e.end],e.loop),r=Ri(t,n,s);for(const t of r)a.push({source:t,target:e,start:{[i]:ia(l,s,"start",Math.max)},end:{[i]:ia(l,s,"end",Math.min)}})}}return a}(i,s,n);for(const{source:e,target:l,start:h,end:c}of r){const{style:{backgroundColor:r=o}={}}=e,d=!0!==s;t.save(),t.fillStyle=r,ga(t,a,d&&ta(n,h,c)),t.beginPath();const u=!!i.pathSegment(t,e);let f;if(d){u?t.closePath():pa(t,s,c,n);const e=!!s.pathSegment(t,l,{move:u,reverse:!0});f=u&&e,f||pa(t,s,h,n)}t.closePath(),t.fill(f?"evenodd":"nonzero"),t.restore()}}function ga(t,e,i){const{top:s,bottom:n}=e.chart.chartArea,{property:o,start:a,end:r}=i||{};"x"===o&&(t.beginPath(),t.rect(a,s,r-a,n-s),t.clip())}function pa(t,e,i,s){const n=e.interpolate(i,s);n&&t.lineTo(n.x,n.y)}var ma={id:"filler",afterDatasetsUpdate(t,e,i){const s=(t.data.datasets||[]).length,n=[];let o,a,r,l;for(a=0;a<s;++a)o=t.getDatasetMeta(a),r=o.dataset,l=null,r&&r.options&&r instanceof no&&(l={visible:t.isDatasetVisible(a),index:a,fill:aa(r,a,s),chart:t,axis:o.controller.options.indexAxis,scale:o.vScale,line:r}),o.$filler=l,n.push(l);for(a=0;a<s;++a)l=n[a],l&&!1!==l.fill&&(l.fill=oa(n,a,i.propagate))},beforeDraw(t,e,i){const s="beforeDraw"===i.drawTime,n=t.getSortedVisibleDatasetMetas(),o=t.chartArea;for(let e=n.length-1;e>=0;--e){const i=n[e].$filler;i&&(i.line.updateControlPoints(o,i.axis),s&&i.fill&&da(t.ctx,i,o))}},beforeDatasetsDraw(t,e,i){if("beforeDatasetsDraw"!==i.drawTime)return;const s=t.getSortedVisibleDatasetMetas();for(let e=s.length-1;e>=0;--e){const i=s[e].$filler;na(i)&&da(t.ctx,i,t.chartArea)}},beforeDatasetDraw(t,e,i){const s=e.meta.$filler;na(s)&&"beforeDatasetDraw"===i.drawTime&&da(t.ctx,s,t.chartArea)},defaults:{propagate:!0,drawTime:"beforeDatasetDraw"}};const xa=(t,e)=>{let{boxHeight:i=e,boxWidth:s=e}=t;return t.usePointStyle&&(i=Math.min(i,e),s=t.pointStyleWidth||Math.min(s,e)),{boxWidth:s,boxHeight:i,itemHeight:Math.max(e,i)}};class ba extends Hs{constructor(t){super(),this._added=!1,this.legendHitBoxes=[],this._hoveredItem=null,this.doughnutMode=!1,this.chart=t.chart,this.options=t.options,this.ctx=t.ctx,this.legendItems=void 0,this.columnSizes=void 0,this.lineWidths=void 0,this.maxHeight=void 0,this.maxWidth=void 0,this.top=void 0,this.bottom=void 0,this.left=void 0,this.right=void 0,this.height=void 0,this.width=void 0,this._margins=void 0,this.position=void 0,this.weight=void 0,this.fullSize=void 0}update(t,e,i){this.maxWidth=t,this.maxHeight=e,this._margins=i,this.setDimensions(),this.buildLabels(),this.fit()}setDimensions(){this.isHorizontal()?(this.width=this.maxWidth,this.left=this._margins.left,this.right=this.width):(this.height=this.maxHeight,this.top=this._margins.top,this.bottom=this.height)}buildLabels(){const t=this.options.labels||{};let e=d(t.generateLabels,[this.chart],this)||[];t.filter&&(e=e.filter((e=>t.filter(e,this.chart.data)))),t.sort&&(e=e.sort(((e,i)=>t.sort(e,i,this.chart.data)))),this.options.reverse&&e.reverse(),this.legendItems=e}fit(){const{options:t,ctx:e}=this;if(!t.display)return void(this.width=this.height=0);const i=t.labels,s=Si(i.font),n=s.size,o=this._computeTitleHeight(),{boxWidth:a,itemHeight:r}=xa(i,n);let l,h;e.font=s.string,this.isHorizontal()?(l=this.maxWidth,h=this._fitRows(o,n,a,r)+10):(h=this.maxHeight,l=this._fitCols(o,s,a,r)+10),this.width=Math.min(l,t.maxWidth||this.maxWidth),this.height=Math.min(h,t.maxHeight||this.maxHeight)}_fitRows(t,e,i,s){const{ctx:n,maxWidth:o,options:{labels:{padding:a}}}=this,r=this.legendHitBoxes=[],l=this.lineWidths=[0],h=s+a;let c=t;n.textAlign="left",n.textBaseline="middle";let d=-1,u=-h;return this.legendItems.forEach(((t,f)=>{const g=i+e/2+n.measureText(t.text).width;(0===f||l[l.length-1]+g+2*a>o)&&(c+=h,l[l.length-(f>0?0:1)]=0,u+=h,d++),r[f]={left:0,top:u,row:d,width:g,height:s},l[l.length-1]+=g+a})),c}_fitCols(t,e,i,s){const{ctx:n,maxHeight:o,options:{labels:{padding:a}}}=this,r=this.legendHitBoxes=[],l=this.columnSizes=[],h=o-t;let c=a,d=0,u=0,f=0,g=0;return this.legendItems.forEach(((t,o)=>{const{itemWidth:p,itemHeight:m}=function(t,e,i,s,n){const o=function(t,e,i,s){let n=t.text;n&&"string"!=typeof n&&(n=n.reduce(((t,e)=>t.length>e.length?t:e)));return e+i.size/2+s.measureText(n).width}(s,t,e,i),a=function(t,e,i){let s=t;"string"!=typeof e.text&&(s=_a(e,i));return s}(n,s,e.lineHeight);return{itemWidth:o,itemHeight:a}}(i,e,n,t,s);o>0&&u+m+2*a>h&&(c+=d+a,l.push({width:d,height:u}),f+=d+a,g++,d=u=0),r[o]={left:f,top:u,col:g,width:p,height:m},d=Math.max(d,p),u+=m+a})),c+=d,l.push({width:d,height:u}),c}adjustHitBoxes(){if(!this.options.display)return;const t=this._computeTitleHeight(),{legendHitBoxes:e,options:{align:i,labels:{padding:s},rtl:n}}=this,o=Oi(n,this.left,this.width);if(this.isHorizontal()){let n=0,a=ft(i,this.left+s,this.right-this.lineWidths[n]);for(const r of e)n!==r.row&&(n=r.row,a=ft(i,this.left+s,this.right-this.lineWidths[n])),r.top+=this.top+t+s,r.left=o.leftForLtr(o.x(a),r.width),a+=r.width+s}else{let n=0,a=ft(i,this.top+t+s,this.bottom-this.columnSizes[n].height);for(const r of e)r.col!==n&&(n=r.col,a=ft(i,this.top+t+s,this.bottom-this.columnSizes[n].height)),r.top=a,r.left+=this.left+s,r.left=o.leftForLtr(o.x(r.left),r.width),a+=r.height+s}}isHorizontal(){return"top"===this.options.position||"bottom"===this.options.position}draw(){if(this.options.display){const t=this.ctx;Ie(t,this),this._draw(),ze(t)}}_draw(){const{options:t,columnSizes:e,lineWidths:i,ctx:s}=this,{align:n,labels:o}=t,a=ue.color,r=Oi(t.rtl,this.left,this.width),h=Si(o.font),{padding:c}=o,d=h.size,u=d/2;let f;this.drawTitle(),s.textAlign=r.textAlign("left"),s.textBaseline="middle",s.lineWidth=.5,s.font=h.string;const{boxWidth:g,boxHeight:p,itemHeight:m}=xa(o,d),x=this.isHorizontal(),b=this._computeTitleHeight();f=x?{x:ft(n,this.left+c,this.right-i[0]),y:this.top+c+b,line:0}:{x:this.left+c,y:ft(n,this.top+b+c,this.bottom-e[0].height),line:0},Ai(this.ctx,t.textDirection);const _=m+c;this.legendItems.forEach(((y,v)=>{s.strokeStyle=y.fontColor,s.fillStyle=y.fontColor;const M=s.measureText(y.text).width,w=r.textAlign(y.textAlign||(y.textAlign=o.textAlign)),k=g+u+M;let S=f.x,P=f.y;r.setWidth(this.width),x?v>0&&S+k+c>this.right&&(P=f.y+=_,f.line++,S=f.x=ft(n,this.left+c,this.right-i[f.line])):v>0&&P+_>this.bottom&&(S=f.x=S+e[f.line].width+c,f.line++,P=f.y=ft(n,this.top+b+c,this.bottom-e[f.line].height));if(function(t,e,i){if(isNaN(g)||g<=0||isNaN(p)||p<0)return;s.save();const n=l(i.lineWidth,1);if(s.fillStyle=l(i.fillStyle,a),s.lineCap=l(i.lineCap,"butt"),s.lineDashOffset=l(i.lineDashOffset,0),s.lineJoin=l(i.lineJoin,"miter"),s.lineWidth=n,s.strokeStyle=l(i.strokeStyle,a),s.setLineDash(l(i.lineDash,[])),o.usePointStyle){const a={radius:p*Math.SQRT2/2,pointStyle:i.pointStyle,rotation:i.rotation,borderWidth:n},l=r.xPlus(t,g/2);Ee(s,a,l,e+u,o.pointStyleWidth&&g)}else{const o=e+Math.max((d-p)/2,0),a=r.leftForLtr(t,g),l=wi(i.borderRadius);s.beginPath(),Object.values(l).some((t=>0!==t))?He(s,{x:a,y:o,w:g,h:p,radius:l}):s.rect(a,o,g,p),s.fill(),0!==n&&s.stroke()}s.restore()}(r.x(S),P,y),S=gt(w,S+g+u,x?S+k:this.right,t.rtl),function(t,e,i){Ne(s,i.text,t,e+m/2,h,{strikethrough:i.hidden,textAlign:r.textAlign(i.textAlign)})}(r.x(S),P,y),x)f.x+=k+c;else if("string"!=typeof y.text){const t=h.lineHeight;f.y+=_a(y,t)+c}else f.y+=_})),Ti(this.ctx,t.textDirection)}drawTitle(){const t=this.options,e=t.title,i=Si(e.font),s=ki(e.padding);if(!e.display)return;const n=Oi(t.rtl,this.left,this.width),o=this.ctx,a=e.position,r=i.size/2,l=s.top+r;let h,c=this.left,d=this.width;if(this.isHorizontal())d=Math.max(...this.lineWidths),h=this.top+l,c=ft(t.align,c,this.right-d);else{const e=this.columnSizes.reduce(((t,e)=>Math.max(t,e.height)),0);h=l+ft(t.align,this.top,this.bottom-e-t.labels.padding-this._computeTitleHeight())}const u=ft(a,c,c+d);o.textAlign=n.textAlign(ut(a)),o.textBaseline="middle",o.strokeStyle=e.color,o.fillStyle=e.color,o.font=i.string,Ne(o,e.text,u,h,i)}_computeTitleHeight(){const t=this.options.title,e=Si(t.font),i=ki(t.padding);return t.display?e.lineHeight+i.height:0}_getLegendItemAt(t,e){let i,s,n;if(tt(t,this.left,this.right)&&tt(e,this.top,this.bottom))for(n=this.legendHitBoxes,i=0;i<n.length;++i)if(s=n[i],tt(t,s.left,s.left+s.width)&&tt(e,s.top,s.top+s.height))return this.legendItems[i];return null}handleEvent(t){const e=this.options;if(!function(t,e){if(("mousemove"===t||"mouseout"===t)&&(e.onHover||e.onLeave))return!0;if(e.onClick&&("click"===t||"mouseup"===t))return!0;return!1}(t.type,e))return;const i=this._getLegendItemAt(t.x,t.y);if("mousemove"===t.type||"mouseout"===t.type){const o=this._hoveredItem,a=(n=i,null!==(s=o)&&null!==n&&s.datasetIndex===n.datasetIndex&&s.index===n.index);o&&!a&&d(e.onLeave,[t,o,this],this),this._hoveredItem=i,i&&!a&&d(e.onHover,[t,i,this],this)}else i&&d(e.onClick,[t,i,this],this);var s,n}}function _a(t,e){return e*(t.text?t.text.length:0)}var ya={id:"legend",_element:ba,start(t,e,i){const s=t.legend=new ba({ctx:t.ctx,options:i,chart:t});as.configure(t,s,i),as.addBox(t,s)},stop(t){as.removeBox(t,t.legend),delete t.legend},beforeUpdate(t,e,i){const s=t.legend;as.configure(t,s,i),s.options=i},afterUpdate(t){const e=t.legend;e.buildLabels(),e.adjustHitBoxes()},afterEvent(t,e){e.replay||t.legend.handleEvent(e.event)},defaults:{display:!0,position:"top",align:"center",fullSize:!0,reverse:!1,weight:1e3,onClick(t,e,i){const s=e.datasetIndex,n=i.chart;n.isDatasetVisible(s)?(n.hide(s),e.hidden=!0):(n.show(s),e.hidden=!1)},onHover:null,onLeave:null,labels:{color:t=>t.chart.options.color,boxWidth:40,padding:10,generateLabels(t){const e=t.data.datasets,{labels:{usePointStyle:i,pointStyle:s,textAlign:n,color:o,useBorderRadius:a,borderRadius:r}}=t.legend.options;return t._getSortedDatasetMetas().map((t=>{const l=t.controller.getStyle(i?0:void 0),h=ki(l.borderWidth);return{text:e[t.index].label,fillStyle:l.backgroundColor,fontColor:o,hidden:!t.visible,lineCap:l.borderCapStyle,lineDash:l.borderDash,lineDashOffset:l.borderDashOffset,lineJoin:l.borderJoinStyle,lineWidth:(h.width+h.height)/4,strokeStyle:l.borderColor,pointStyle:s||l.pointStyle,rotation:l.rotation,textAlign:n||l.textAlign,borderRadius:a&&(r||l.borderRadius),datasetIndex:t.index}}),this)}},title:{color:t=>t.chart.options.color,display:!1,position:"center",text:""}},descriptors:{_scriptable:t=>!t.startsWith("on"),labels:{_scriptable:t=>!["generateLabels","filter","sort"].includes(t)}}};class va extends Hs{constructor(t){super(),this.chart=t.chart,this.options=t.options,this.ctx=t.ctx,this._padding=void 0,this.top=void 0,this.bottom=void 0,this.left=void 0,this.right=void 0,this.width=void 0,this.height=void 0,this.position=void 0,this.weight=void 0,this.fullSize=void 0}update(t,e){const i=this.options;if(this.left=0,this.top=0,!i.display)return void(this.width=this.height=this.right=this.bottom=0);this.width=this.right=t,this.height=this.bottom=e;const s=n(i.text)?i.text.length:1;this._padding=ki(i.padding);const o=s*Si(i.font).lineHeight+this._padding.height;this.isHorizontal()?this.height=o:this.width=o}isHorizontal(){const t=this.options.position;return"top"===t||"bottom"===t}_drawArgs(t){const{top:e,left:i,bottom:s,right:n,options:o}=this,a=o.align;let r,l,h,c=0;return this.isHorizontal()?(l=ft(a,i,n),h=e+t,r=n-i):("left"===o.position?(l=i+t,h=ft(a,s,e),c=-.5*C):(l=n-t,h=ft(a,e,s),c=.5*C),r=s-e),{titleX:l,titleY:h,maxWidth:r,rotation:c}}draw(){const t=this.ctx,e=this.options;if(!e.display)return;const i=Si(e.font),s=i.lineHeight/2+this._padding.top,{titleX:n,titleY:o,maxWidth:a,rotation:r}=this._drawArgs(s);Ne(t,e.text,0,0,i,{color:e.color,maxWidth:a,rotation:r,textAlign:ut(e.align),textBaseline:"middle",translation:[n,o]})}}var Ma={id:"title",_element:va,start(t,e,i){!function(t,e){const i=new va({ctx:t.ctx,options:e,chart:t});as.configure(t,i,e),as.addBox(t,i),t.titleBlock=i}(t,i)},stop(t){const e=t.titleBlock;as.removeBox(t,e),delete t.titleBlock},beforeUpdate(t,e,i){const s=t.titleBlock;as.configure(t,s,i),s.options=i},defaults:{align:"center",display:!1,font:{weight:"bold"},fullSize:!0,padding:10,position:"top",text:"",weight:2e3},defaultRoutes:{color:"color"},descriptors:{_scriptable:!0,_indexable:!1}};const wa=new WeakMap;var ka={id:"subtitle",start(t,e,i){const s=new va({ctx:t.ctx,options:i,chart:t});as.configure(t,s,i),as.addBox(t,s),wa.set(t,s)},stop(t){as.removeBox(t,wa.get(t)),wa.delete(t)},beforeUpdate(t,e,i){const s=wa.get(t);as.configure(t,s,i),s.options=i},defaults:{align:"center",display:!1,font:{weight:"normal"},fullSize:!0,padding:0,position:"top",text:"",weight:1500},defaultRoutes:{color:"color"},descriptors:{_scriptable:!0,_indexable:!1}};const Sa={average(t){if(!t.length)return!1;let e,i,s=new Set,n=0,o=0;for(e=0,i=t.length;e<i;++e){const i=t[e].element;if(i&&i.hasValue()){const t=i.tooltipPosition();s.add(t.x),n+=t.y,++o}}if(0===o||0===s.size)return!1;return{x:[...s].reduce(((t,e)=>t+e))/s.size,y:n/o}},nearest(t,e){if(!t.length)return!1;let i,s,n,o=e.x,a=e.y,r=Number.POSITIVE_INFINITY;for(i=0,s=t.length;i<s;++i){const s=t[i].element;if(s&&s.hasValue()){const t=q(e,s.getCenterPoint());t<r&&(r=t,n=s)}}if(n){const t=n.tooltipPosition();o=t.x,a=t.y}return{x:o,y:a}}};function Pa(t,e){return e&&(n(e)?Array.prototype.push.apply(t,e):t.push(e)),t}function Da(t){return("string"==typeof t||t instanceof String)&&t.indexOf("\n")>-1?t.split("\n"):t}function Ca(t,e){const{element:i,datasetIndex:s,index:n}=e,o=t.getDatasetMeta(s).controller,{label:a,value:r}=o.getLabelAndValue(n);return{chart:t,label:a,parsed:o.getParsed(n),raw:t.data.datasets[s].data[n],formattedValue:r,dataset:o.getDataset(),dataIndex:n,datasetIndex:s,element:i}}function Oa(t,e){const i=t.chart.ctx,{body:s,footer:n,title:o}=t,{boxWidth:a,boxHeight:r}=e,l=Si(e.bodyFont),h=Si(e.titleFont),c=Si(e.footerFont),d=o.length,f=n.length,g=s.length,p=ki(e.padding);let m=p.height,x=0,b=s.reduce(((t,e)=>t+e.before.length+e.lines.length+e.after.length),0);if(b+=t.beforeBody.length+t.afterBody.length,d&&(m+=d*h.lineHeight+(d-1)*e.titleSpacing+e.titleMarginBottom),b){m+=g*(e.displayColors?Math.max(r,l.lineHeight):l.lineHeight)+(b-g)*l.lineHeight+(b-1)*e.bodySpacing}f&&(m+=e.footerMarginTop+f*c.lineHeight+(f-1)*e.footerSpacing);let _=0;const y=function(t){x=Math.max(x,i.measureText(t).width+_)};return i.save(),i.font=h.string,u(t.title,y),i.font=l.string,u(t.beforeBody.concat(t.afterBody),y),_=e.displayColors?a+2+e.boxPadding:0,u(s,(t=>{u(t.before,y),u(t.lines,y),u(t.after,y)})),_=0,i.font=c.string,u(t.footer,y),i.restore(),x+=p.width,{width:x,height:m}}function Aa(t,e,i,s){const{x:n,width:o}=i,{width:a,chartArea:{left:r,right:l}}=t;let h="center";return"center"===s?h=n<=(r+l)/2?"left":"right":n<=o/2?h="left":n>=a-o/2&&(h="right"),function(t,e,i,s){const{x:n,width:o}=s,a=i.caretSize+i.caretPadding;return"left"===t&&n+o+a>e.width||"right"===t&&n-o-a<0||void 0}(h,t,e,i)&&(h="center"),h}function Ta(t,e,i){const s=i.yAlign||e.yAlign||function(t,e){const{y:i,height:s}=e;return i<s/2?"top":i>t.height-s/2?"bottom":"center"}(t,i);return{xAlign:i.xAlign||e.xAlign||Aa(t,e,i,s),yAlign:s}}function La(t,e,i,s){const{caretSize:n,caretPadding:o,cornerRadius:a}=t,{xAlign:r,yAlign:l}=i,h=n+o,{topLeft:c,topRight:d,bottomLeft:u,bottomRight:f}=wi(a);let g=function(t,e){let{x:i,width:s}=t;return"right"===e?i-=s:"center"===e&&(i-=s/2),i}(e,r);const p=function(t,e,i){let{y:s,height:n}=t;return"top"===e?s+=i:s-="bottom"===e?n+i:n/2,s}(e,l,h);return"center"===l?"left"===r?g+=h:"right"===r&&(g-=h):"left"===r?g-=Math.max(c,u)+n:"right"===r&&(g+=Math.max(d,f)+n),{x:J(g,0,s.width-e.width),y:J(p,0,s.height-e.height)}}function Ea(t,e,i){const s=ki(i.padding);return"center"===e?t.x+t.width/2:"right"===e?t.x+t.width-s.right:t.x+s.left}function Ra(t){return Pa([],Da(t))}function Ia(t,e){const i=e&&e.dataset&&e.dataset.tooltip&&e.dataset.tooltip.callbacks;return i?t.override(i):t}const za={beforeTitle:e,title(t){if(t.length>0){const e=t[0],i=e.chart.data.labels,s=i?i.length:0;if(this&&this.options&&"dataset"===this.options.mode)return e.dataset.label||"";if(e.label)return e.label;if(s>0&&e.dataIndex<s)return i[e.dataIndex]}return""},afterTitle:e,beforeBody:e,beforeLabel:e,label(t){if(this&&this.options&&"dataset"===this.options.mode)return t.label+": "+t.formattedValue||t.formattedValue;let e=t.dataset.label||"";e&&(e+=": ");const i=t.formattedValue;return s(i)||(e+=i),e},labelColor(t){const e=t.chart.getDatasetMeta(t.datasetIndex).controller.getStyle(t.dataIndex);return{borderColor:e.borderColor,backgroundColor:e.backgroundColor,borderWidth:e.borderWidth,borderDash:e.borderDash,borderDashOffset:e.borderDashOffset,borderRadius:0}},labelTextColor(){return this.options.bodyColor},labelPointStyle(t){const e=t.chart.getDatasetMeta(t.datasetIndex).controller.getStyle(t.dataIndex);return{pointStyle:e.pointStyle,rotation:e.rotation}},afterLabel:e,afterBody:e,beforeFooter:e,footer:e,afterFooter:e};function Fa(t,e,i,s){const n=t[e].call(i,s);return void 0===n?za[e].call(i,s):n}class Va extends Hs{static positioners=Sa;constructor(t){super(),this.opacity=0,this._active=[],this._eventPosition=void 0,this._size=void 0,this._cachedAnimations=void 0,this._tooltipItems=[],this.$animations=void 0,this.$context=void 0,this.chart=t.chart,this.options=t.options,this.dataPoints=void 0,this.title=void 0,this.beforeBody=void 0,this.body=void 0,this.afterBody=void 0,this.footer=void 0,this.xAlign=void 0,this.yAlign=void 0,this.x=void 0,this.y=void 0,this.height=void 0,this.width=void 0,this.caretX=void 0,this.caretY=void 0,this.labelColors=void 0,this.labelPointStyles=void 0,this.labelTextColors=void 0}initialize(t){this.options=t,this._cachedAnimations=void 0,this.$context=void 0}_resolveAnimations(){const t=this._cachedAnimations;if(t)return t;const e=this.chart,i=this.options.setContext(this.getContext()),s=i.enabled&&e.options.animation&&i.animations,n=new Os(this.chart,s);return s._cacheable&&(this._cachedAnimations=Object.freeze(n)),n}getContext(){return this.$context||(this.$context=(t=this.chart.getContext(),e=this,i=this._tooltipItems,Ci(t,{tooltip:e,tooltipItems:i,type:"tooltip"})));var t,e,i}getTitle(t,e){const{callbacks:i}=e,s=Fa(i,"beforeTitle",this,t),n=Fa(i,"title",this,t),o=Fa(i,"afterTitle",this,t);let a=[];return a=Pa(a,Da(s)),a=Pa(a,Da(n)),a=Pa(a,Da(o)),a}getBeforeBody(t,e){return Ra(Fa(e.callbacks,"beforeBody",this,t))}getBody(t,e){const{callbacks:i}=e,s=[];return u(t,(t=>{const e={before:[],lines:[],after:[]},n=Ia(i,t);Pa(e.before,Da(Fa(n,"beforeLabel",this,t))),Pa(e.lines,Fa(n,"label",this,t)),Pa(e.after,Da(Fa(n,"afterLabel",this,t))),s.push(e)})),s}getAfterBody(t,e){return Ra(Fa(e.callbacks,"afterBody",this,t))}getFooter(t,e){const{callbacks:i}=e,s=Fa(i,"beforeFooter",this,t),n=Fa(i,"footer",this,t),o=Fa(i,"afterFooter",this,t);let a=[];return a=Pa(a,Da(s)),a=Pa(a,Da(n)),a=Pa(a,Da(o)),a}_createItems(t){const e=this._active,i=this.chart.data,s=[],n=[],o=[];let a,r,l=[];for(a=0,r=e.length;a<r;++a)l.push(Ca(this.chart,e[a]));return t.filter&&(l=l.filter(((e,s,n)=>t.filter(e,s,n,i)))),t.itemSort&&(l=l.sort(((e,s)=>t.itemSort(e,s,i)))),u(l,(e=>{const i=Ia(t.callbacks,e);s.push(Fa(i,"labelColor",this,e)),n.push(Fa(i,"labelPointStyle",this,e)),o.push(Fa(i,"labelTextColor",this,e))})),this.labelColors=s,this.labelPointStyles=n,this.labelTextColors=o,this.dataPoints=l,l}update(t,e){const i=this.options.setContext(this.getContext()),s=this._active;let n,o=[];if(s.length){const t=Sa[i.position].call(this,s,this._eventPosition);o=this._createItems(i),this.title=this.getTitle(o,i),this.beforeBody=this.getBeforeBody(o,i),this.body=this.getBody(o,i),this.afterBody=this.getAfterBody(o,i),this.footer=this.getFooter(o,i);const e=this._size=Oa(this,i),a=Object.assign({},t,e),r=Ta(this.chart,i,a),l=La(i,a,r,this.chart);this.xAlign=r.xAlign,this.yAlign=r.yAlign,n={opacity:1,x:l.x,y:l.y,width:e.width,height:e.height,caretX:t.x,caretY:t.y}}else 0!==this.opacity&&(n={opacity:0});this._tooltipItems=o,this.$context=void 0,n&&this._resolveAnimations().update(this,n),t&&i.external&&i.external.call(this,{chart:this.chart,tooltip:this,replay:e})}drawCaret(t,e,i,s){const n=this.getCaretPosition(t,i,s);e.lineTo(n.x1,n.y1),e.lineTo(n.x2,n.y2),e.lineTo(n.x3,n.y3)}getCaretPosition(t,e,i){const{xAlign:s,yAlign:n}=this,{caretSize:o,cornerRadius:a}=i,{topLeft:r,topRight:l,bottomLeft:h,bottomRight:c}=wi(a),{x:d,y:u}=t,{width:f,height:g}=e;let p,m,x,b,_,y;return"center"===n?(_=u+g/2,"left"===s?(p=d,m=p-o,b=_+o,y=_-o):(p=d+f,m=p+o,b=_-o,y=_+o),x=p):(m="left"===s?d+Math.max(r,h)+o:"right"===s?d+f-Math.max(l,c)-o:this.caretX,"top"===n?(b=u,_=b-o,p=m-o,x=m+o):(b=u+g,_=b+o,p=m+o,x=m-o),y=b),{x1:p,x2:m,x3:x,y1:b,y2:_,y3:y}}drawTitle(t,e,i){const s=this.title,n=s.length;let o,a,r;if(n){const l=Oi(i.rtl,this.x,this.width);for(t.x=Ea(this,i.titleAlign,i),e.textAlign=l.textAlign(i.titleAlign),e.textBaseline="middle",o=Si(i.titleFont),a=i.titleSpacing,e.fillStyle=i.titleColor,e.font=o.string,r=0;r<n;++r)e.fillText(s[r],l.x(t.x),t.y+o.lineHeight/2),t.y+=o.lineHeight+a,r+1===n&&(t.y+=i.titleMarginBottom-a)}}_drawColorBox(t,e,i,s,n){const a=this.labelColors[i],r=this.labelPointStyles[i],{boxHeight:l,boxWidth:h}=n,c=Si(n.bodyFont),d=Ea(this,"left",n),u=s.x(d),f=l<c.lineHeight?(c.lineHeight-l)/2:0,g=e.y+f;if(n.usePointStyle){const e={radius:Math.min(h,l)/2,pointStyle:r.pointStyle,rotation:r.rotation,borderWidth:1},i=s.leftForLtr(u,h)+h/2,o=g+l/2;t.strokeStyle=n.multiKeyBackground,t.fillStyle=n.multiKeyBackground,Le(t,e,i,o),t.strokeStyle=a.borderColor,t.fillStyle=a.backgroundColor,Le(t,e,i,o)}else{t.lineWidth=o(a.borderWidth)?Math.max(...Object.values(a.borderWidth)):a.borderWidth||1,t.strokeStyle=a.borderColor,t.setLineDash(a.borderDash||[]),t.lineDashOffset=a.borderDashOffset||0;const e=s.leftForLtr(u,h),i=s.leftForLtr(s.xPlus(u,1),h-2),r=wi(a.borderRadius);Object.values(r).some((t=>0!==t))?(t.beginPath(),t.fillStyle=n.multiKeyBackground,He(t,{x:e,y:g,w:h,h:l,radius:r}),t.fill(),t.stroke(),t.fillStyle=a.backgroundColor,t.beginPath(),He(t,{x:i,y:g+1,w:h-2,h:l-2,radius:r}),t.fill()):(t.fillStyle=n.multiKeyBackground,t.fillRect(e,g,h,l),t.strokeRect(e,g,h,l),t.fillStyle=a.backgroundColor,t.fillRect(i,g+1,h-2,l-2))}t.fillStyle=this.labelTextColors[i]}drawBody(t,e,i){const{body:s}=this,{bodySpacing:n,bodyAlign:o,displayColors:a,boxHeight:r,boxWidth:l,boxPadding:h}=i,c=Si(i.bodyFont);let d=c.lineHeight,f=0;const g=Oi(i.rtl,this.x,this.width),p=function(i){e.fillText(i,g.x(t.x+f),t.y+d/2),t.y+=d+n},m=g.textAlign(o);let x,b,_,y,v,M,w;for(e.textAlign=o,e.textBaseline="middle",e.font=c.string,t.x=Ea(this,m,i),e.fillStyle=i.bodyColor,u(this.beforeBody,p),f=a&&"right"!==m?"center"===o?l/2+h:l+2+h:0,y=0,M=s.length;y<M;++y){for(x=s[y],b=this.labelTextColors[y],e.fillStyle=b,u(x.before,p),_=x.lines,a&&_.length&&(this._drawColorBox(e,t,y,g,i),d=Math.max(c.lineHeight,r)),v=0,w=_.length;v<w;++v)p(_[v]),d=c.lineHeight;u(x.after,p)}f=0,d=c.lineHeight,u(this.afterBody,p),t.y-=n}drawFooter(t,e,i){const s=this.footer,n=s.length;let o,a;if(n){const r=Oi(i.rtl,this.x,this.width);for(t.x=Ea(this,i.footerAlign,i),t.y+=i.footerMarginTop,e.textAlign=r.textAlign(i.footerAlign),e.textBaseline="middle",o=Si(i.footerFont),e.fillStyle=i.footerColor,e.font=o.string,a=0;a<n;++a)e.fillText(s[a],r.x(t.x),t.y+o.lineHeight/2),t.y+=o.lineHeight+i.footerSpacing}}drawBackground(t,e,i,s){const{xAlign:n,yAlign:o}=this,{x:a,y:r}=t,{width:l,height:h}=i,{topLeft:c,topRight:d,bottomLeft:u,bottomRight:f}=wi(s.cornerRadius);e.fillStyle=s.backgroundColor,e.strokeStyle=s.borderColor,e.lineWidth=s.borderWidth,e.beginPath(),e.moveTo(a+c,r),"top"===o&&this.drawCaret(t,e,i,s),e.lineTo(a+l-d,r),e.quadraticCurveTo(a+l,r,a+l,r+d),"center"===o&&"right"===n&&this.drawCaret(t,e,i,s),e.lineTo(a+l,r+h-f),e.quadraticCurveTo(a+l,r+h,a+l-f,r+h),"bottom"===o&&this.drawCaret(t,e,i,s),e.lineTo(a+u,r+h),e.quadraticCurveTo(a,r+h,a,r+h-u),"center"===o&&"left"===n&&this.drawCaret(t,e,i,s),e.lineTo(a,r+c),e.quadraticCurveTo(a,r,a+c,r),e.closePath(),e.fill(),s.borderWidth>0&&e.stroke()}_updateAnimationTarget(t){const e=this.chart,i=this.$animations,s=i&&i.x,n=i&&i.y;if(s||n){const i=Sa[t.position].call(this,this._active,this._eventPosition);if(!i)return;const o=this._size=Oa(this,t),a=Object.assign({},i,this._size),r=Ta(e,t,a),l=La(t,a,r,e);s._to===l.x&&n._to===l.y||(this.xAlign=r.xAlign,this.yAlign=r.yAlign,this.width=o.width,this.height=o.height,this.caretX=i.x,this.caretY=i.y,this._resolveAnimations().update(this,l))}}_willRender(){return!!this.opacity}draw(t){const e=this.options.setContext(this.getContext());let i=this.opacity;if(!i)return;this._updateAnimationTarget(e);const s={width:this.width,height:this.height},n={x:this.x,y:this.y};i=Math.abs(i)<.001?0:i;const o=ki(e.padding),a=this.title.length||this.beforeBody.length||this.body.length||this.afterBody.length||this.footer.length;e.enabled&&a&&(t.save(),t.globalAlpha=i,this.drawBackground(n,t,s,e),Ai(t,e.textDirection),n.y+=o.top,this.drawTitle(n,t,e),this.drawBody(n,t,e),this.drawFooter(n,t,e),Ti(t,e.textDirection),t.restore())}getActiveElements(){return this._active||[]}setActiveElements(t,e){const i=this._active,s=t.map((({datasetIndex:t,index:e})=>{const i=this.chart.getDatasetMeta(t);if(!i)throw new Error("Cannot find a dataset at index "+t);return{datasetIndex:t,element:i.data[e],index:e}})),n=!f(i,s),o=this._positionChanged(s,e);(n||o)&&(this._active=s,this._eventPosition=e,this._ignoreReplayEvents=!0,this.update(!0))}handleEvent(t,e,i=!0){if(e&&this._ignoreReplayEvents)return!1;this._ignoreReplayEvents=!1;const s=this.options,n=this._active||[],o=this._getActiveElements(t,n,e,i),a=this._positionChanged(o,t),r=e||!f(o,n)||a;return r&&(this._active=o,(s.enabled||s.external)&&(this._eventPosition={x:t.x,y:t.y},this.update(!0,e))),r}_getActiveElements(t,e,i,s){const n=this.options;if("mouseout"===t.type)return[];if(!s)return e.filter((t=>this.chart.data.datasets[t.datasetIndex]&&void 0!==this.chart.getDatasetMeta(t.datasetIndex).controller.getParsed(t.index)));const o=this.chart.getElementsAtEventForMode(t,n.mode,n,i);return n.reverse&&o.reverse(),o}_positionChanged(t,e){const{caretX:i,caretY:s,options:n}=this,o=Sa[n.position].call(this,t,e);return!1!==o&&(i!==o.x||s!==o.y)}}var Ba={id:"tooltip",_element:Va,positioners:Sa,afterInit(t,e,i){i&&(t.tooltip=new Va({chart:t,options:i}))},beforeUpdate(t,e,i){t.tooltip&&t.tooltip.initialize(i)},reset(t,e,i){t.tooltip&&t.tooltip.initialize(i)},afterDraw(t){const e=t.tooltip;if(e&&e._willRender()){const i={tooltip:e};if(!1===t.notifyPlugins("beforeTooltipDraw",{...i,cancelable:!0}))return;e.draw(t.ctx),t.notifyPlugins("afterTooltipDraw",i)}},afterEvent(t,e){if(t.tooltip){const i=e.replay;t.tooltip.handleEvent(e.event,i,e.inChartArea)&&(e.changed=!0)}},defaults:{enabled:!0,external:null,position:"average",backgroundColor:"rgba(0,0,0,0.8)",titleColor:"#fff",titleFont:{weight:"bold"},titleSpacing:2,titleMarginBottom:6,titleAlign:"left",bodyColor:"#fff",bodySpacing:2,bodyFont:{},bodyAlign:"left",footerColor:"#fff",footerSpacing:2,footerMarginTop:6,footerFont:{weight:"bold"},footerAlign:"left",padding:6,caretPadding:2,caretSize:5,cornerRadius:6,boxHeight:(t,e)=>e.bodyFont.size,boxWidth:(t,e)=>e.bodyFont.size,multiKeyBackground:"#fff",displayColors:!0,boxPadding:0,borderColor:"rgba(0,0,0,0)",borderWidth:0,animation:{duration:400,easing:"easeOutQuart"},animations:{numbers:{type:"number",properties:["x","y","width","height","caretX","caretY"]},opacity:{easing:"linear",duration:200}},callbacks:za},defaultRoutes:{bodyFont:"font",footerFont:"font",titleFont:"font"},descriptors:{_scriptable:t=>"filter"!==t&&"itemSort"!==t&&"external"!==t,_indexable:!1,callbacks:{_scriptable:!1,_indexable:!1},animation:{_fallback:!1},animations:{_fallback:"animation"}},additionalOptionScopes:["interaction"]};return An.register(Yn,jo,fo,t),An.helpers={...Wi},An._adapters=Rn,An.Animation=Cs,An.Animations=Os,An.animator=bt,An.controllers=en.controllers.items,An.DatasetController=Ns,An.Element=Hs,An.elements=fo,An.Interaction=Xi,An.layouts=as,An.platforms=Ss,An.Scale=Js,An.Ticks=ae,Object.assign(An,Yn,jo,fo,t,Ss),An.Chart=An,"undefined"!=typeof window&&(window.Chart=An),An}));
-//# sourceMappingURL=chart.umd.js.map
diff --git a/benchmarks-website/server/static/chartjs-plugin-zoom.umd.min.js b/benchmarks-website/server/static/chartjs-plugin-zoom.umd.min.js
deleted file mode 100644
index 0c7b6b45a51..00000000000
--- a/benchmarks-website/server/static/chartjs-plugin-zoom.umd.min.js
+++ /dev/null
@@ -1,7 +0,0 @@
-/*!
-* chartjs-plugin-zoom v2.2.0
-* https://www.chartjs.org/chartjs-plugin-zoom/2.2.0/
- * (c) 2016-2024 chartjs-plugin-zoom Contributors
- * Released under the MIT License
- */
-!function(t,n){"object"==typeof exports&&"undefined"!=typeof module?module.exports=n(require("chart.js"),require("hammerjs"),require("chart.js/helpers")):"function"==typeof define&&define.amd?define(["chart.js","hammerjs","chart.js/helpers"],n):(t="undefined"!=typeof globalThis?globalThis:t||self).ChartZoom=n(t.Chart,t.Hammer,t.Chart.helpers)}(this,(function(t,n,e){"use strict";const o=t=>t&&t.enabled&&t.modifierKey,a=(t,n)=>t&&n[t+"Key"],i=(t,n)=>t&&!n[t+"Key"];function r(t,n,e){return void 0===t||("string"==typeof t?-1!==t.indexOf(n):"function"==typeof t&&-1!==t({chart:e}).indexOf(n))}function c(t,n){return"function"==typeof t&&(t=t({chart:n})),"string"==typeof t?{x:-1!==t.indexOf("x"),y:-1!==t.indexOf("y")}:{x:!1,y:!1}}function s(t,n,o){const{mode:a="xy",scaleMode:i,overScaleMode:r}=t||{},s=function({x:t,y:n},e){const o=e.scales,a=Object.keys(o);for(let e=0;e<a.length;e++){const i=o[a[e]];if(n>=i.top&&n<=i.bottom&&t>=i.left&&t<=i.right)return i}return null}(n,o),l=c(a,o),m=c(i,o);if(r){const t=c(r,o);for(const n of["x","y"])t[n]&&(m[n]=l[n],l[n]=!1)}if(s&&m[s.axis])return[s];const u=[];return e.each(o.scales,(function(t){l[t.axis]&&u.push(t)})),u}const l=new WeakMap;function m(t){let n=l.get(t);return n||(n={originalScaleLimits:{},updatedScaleLimits:{},handlers:{},panDelta:{},dragging:!1,panning:!1},l.set(t,n)),n}function u(t,n,e,o){const a=Math.max(0,Math.min(1,(t-n)/e||0));return{min:o*a,max:o*(1-a)}}function d(t,n){const e=t.isHorizontal()?n.x:n.y;return t.getValueForPixel(e)}function f(t,n,e){const o=t.max-t.min,a=o*(n-1);return u(d(t,e),t.min,o,a)}function p(t,n,o,a,i){let r=o[a];if("original"===r){const o=t.originalScaleLimits[n.id][a];r=e.valueOrDefault(o.options,o.scale)}return e.valueOrDefault(r,i)}function h(t,{min:n,max:o},a,i=!1){const r=m(t.chart),{options:c}=t,s=function(t,n){return n&&(n[t.id]||n[t.axis])||{}}(t,a),{minRange:l=0}=s,u=p(r,t,s,"min",-1/0),d=p(r,t,s,"max",1/0);if("pan"===i&&(n<u||o>d))return!0;const f=t.max-t.min,h=i?Math.max(o-n,l):f;if(i&&h===l&&f<=l)return!0;const g=function(t,{min:n,max:o,minLimit:a,maxLimit:i},r){const c=(t-o+n)/2;n-=c,o+=c;const s=r.min.options??r.min.scale,l=r.max.options??r.max.scale,m=t/1e6;return e.almostEquals(n,s,m)&&(n=s),e.almostEquals(o,l,m)&&(o=l),n<a?(n=a,o=Math.min(a+t,i)):o>i&&(o=i,n=Math.max(i-t,a)),{min:n,max:o}}(h,{min:n,max:o,minLimit:u,maxLimit:d},r.originalScaleLimits[t.id]);return c.min=g.min,c.max=g.max,r.updatedScaleLimits[t.id]=g,t.parse(g.min)!==t.min||t.parse(g.max)!==t.max}const g=t=>0===t||isNaN(t)?0:t<0?Math.min(Math.round(t),-1):Math.max(Math.round(t),1);const x={second:500,minute:3e4,hour:18e5,day:432e5,week:3024e5,month:1296e6,quarter:5184e6,year:157248e5};function b(t,n,e,o=!1){const{min:a,max:i,options:r}=t,c=r.time&&r.time.round,s=x[c]||0,l=t.getValueForPixel(t.getPixelForValue(a+s)-n),m=t.getValueForPixel(t.getPixelForValue(i+s)-n);return!(!isNaN(l)&&!isNaN(m))||h(t,{min:l,max:m},e,!!o&&"pan")}function y(t,n,e){return b(t,n,e,!0)}const v={category:function(t,n,e,o){const a=f(t,n,e);return t.min===t.max&&n<1&&function(t){const n=t.getLabels().length-1;t.min>0&&(t.min-=1),t.max<n&&(t.max+=1)}(t),h(t,{min:t.min+g(a.min),max:t.max-g(a.max)},o,!0)},default:function(t,n,e,o){const a=f(t,n,e);return h(t,{min:t.min+a.min,max:t.max-a.max},o,!0)},logarithmic:function(t,n,e,o){const a=function(t,n,e){const o=d(t,e);if(void 0===o)return{min:t.min,max:t.max};const a=Math.log10(t.min),i=Math.log10(t.max),r=i-a,c=u(Math.log10(o),a,r,r*(n-1));return{min:Math.pow(10,a+c.min),max:Math.pow(10,i-c.max)}}(t,n,e);return h(t,a,o,!0)}},w={default:function(t,n,e,o){h(t,function(t,n,e){const o=t.getValueForPixel(n),a=t.getValueForPixel(e);return{min:Math.min(o,a),max:Math.max(o,a)}}(t,n,e),o,!0)}},z={category:function(t,n,e){const o=t.getLabels().length-1;let{min:a,max:i}=t;const r=Math.max(i-a,1),c=Math.round(function(t){return t.isHorizontal()?t.width:t.height}(t)/Math.max(r,10)),s=Math.round(Math.abs(n/c));let l;return n<-c?(i=Math.min(i+s,o),a=1===r?i:i-r,l=i===o):n>c&&(a=Math.max(0,a-s),i=1===r?a:a+r,l=0===a),h(t,{min:a,max:i},e)||l},default:b,logarithmic:y,timeseries:y};function M(t,n){e.each(t,((e,o)=>{n[o]||delete t[o]}))}function k(t,n){const{scales:o}=t,{originalScaleLimits:a,updatedScaleLimits:i}=n;return e.each(o,(function(t){(function(t,n,e){const{id:o,options:{min:a,max:i}}=t;if(!n[o]||!e[o])return!0;const r=e[o];return r.min!==a||r.max!==i})(t,a,i)&&(a[t.id]={min:{scale:t.min,options:t.options.min},max:{scale:t.max,options:t.options.max}})})),M(a,o),M(i,o),a}function S(t,n,o,a){const i=v[t.type]||v.default;e.callback(i,[t,n,o,a])}function P(t,n,o,a){const i=w[t.type]||w.default;e.callback(i,[t,n,o,a])}function D(t){const n=t.chartArea;return{x:(n.left+n.right)/2,y:(n.top+n.bottom)/2}}function C(t,n,o="none",a="api"){const{x:i=1,y:r=1,focalPoint:c=D(t)}="number"==typeof n?{x:n,y:n}:n,l=m(t),{options:{limits:u,zoom:d}}=l;k(t,l);const f=1!==i,p=1!==r,h=s(d,c,t);e.each(h||t.scales,(function(t){t.isHorizontal()&&f?S(t,i,c,u):!t.isHorizontal()&&p&&S(t,r,c,u)})),t.update(o),e.callback(d.onZoom,[{chart:t,trigger:a}])}function Z(t,n,o,a="none",i="api"){const c=m(t),{options:{limits:s,zoom:l}}=c,{mode:u="xy"}=l;k(t,c);const d=r(u,"x",t),f=r(u,"y",t);e.each(t.scales,(function(t){t.isHorizontal()&&d?P(t,n.x,o.x,s):!t.isHorizontal()&&f&&P(t,n.y,o.y,s)})),t.update(a),e.callback(l.onZoom,[{chart:t,trigger:i}])}function j(t){const n=m(t);let o=1,a=1;return e.each(t.scales,(function(t){const i=function(t,n){const o=t.originalScaleLimits[n];if(!o)return;const{min:a,max:i}=o;return e.valueOrDefault(i.options,i.scale)-e.valueOrDefault(a.options,a.scale)}(n,t.id);if(i){const n=Math.round(i/(t.max-t.min)*100)/100;o=Math.min(o,n),a=Math.max(a,n)}})),o<1?o:a}function L(t,n,o,a){const{panDelta:i}=a,r=i[t.id]||0;e.sign(r)===e.sign(n)&&(n+=r);const c=z[t.type]||z.default;e.callback(c,[t,n,o])?i[t.id]=0:i[t.id]=n}function O(t,n,o,a="none"){const{x:i=0,y:r=0}="number"==typeof n?{x:n,y:n}:n,c=m(t),{options:{pan:s,limits:l}}=c,{onPan:u}=s||{};k(t,c);const d=0!==i,f=0!==r;e.each(o||t.scales,(function(t){t.isHorizontal()&&d?L(t,i,l,c):!t.isHorizontal()&&f&&L(t,r,l,c)})),t.update(a),e.callback(u,[{chart:t}])}function R(t){const n=m(t);k(t,n);const e={};for(const o of Object.keys(t.scales)){const{min:t,max:a}=n.originalScaleLimits[o]||{min:{},max:{}};e[o]={min:t.scale,max:a.scale}}return e}function E(t){const n=m(t);return n.panning||n.dragging}const F=(t,n,e)=>Math.min(e,Math.max(n,t));function N(t,n){const{handlers:e}=m(t),o=e[n];o&&o.target&&(o.target.removeEventListener(n,o),delete e[n])}function A(t,n,e,o){const{handlers:a,options:i}=m(t),r=a[e];if(r&&r.target===n)return;N(t,e),a[e]=n=>o(t,n,i),a[e].target=n;const c="wheel"!==e&&void 0;n.addEventListener(e,a[e],{passive:c})}function H(t,n){const e=m(t);e.dragStart&&(e.dragging=!0,e.dragEnd=n,t.update("none"))}function T(t,n){const e=m(t);e.dragStart&&"Escape"===n.key&&(N(t,"keydown"),e.dragging=!1,e.dragStart=e.dragEnd=null,t.update("none"))}function Y(t,n){if(t.target!==n.canvas){const e=n.canvas.getBoundingClientRect();return{x:t.clientX-e.left,y:t.clientY-e.top}}return e.getRelativePosition(t,n)}function q(t,n,o){const{onZoomStart:a,onZoomRejected:i}=o;if(a){const o=Y(n,t);if(!1===e.callback(a,[{chart:t,event:n,point:o}]))return e.callback(i,[{chart:t,event:n}]),!1}}function V(t,n){if(t.legend){const o=e.getRelativePosition(n,t);if(e._isPointInArea(o,t.legend))return}const r=m(t),{pan:c,zoom:s={}}=r.options;if(0!==n.button||a(o(c),n)||i(o(s.drag),n))return e.callback(s.onZoomRejected,[{chart:t,event:n}]);!1!==q(t,n,s)&&(r.dragStart=n,A(t,t.canvas.ownerDocument,"mousemove",H),A(t,window.document,"keydown",T))}function X(t,n,e,{min:o,max:a,prop:i}){t[o]=F(Math.min(e.begin[i],e.end[i]),n[o],n[a]),t[a]=F(Math.max(e.begin[i],e.end[i]),n[o],n[a])}function B(t,n,e){const o={begin:Y(n.dragStart,t),end:Y(n.dragEnd,t)};if(e){!function({begin:t,end:n},e){let o=n.x-t.x,a=n.y-t.y;const i=Math.abs(o/a);i>e?o=Math.sign(o)*Math.abs(a*e):i<e&&(a=Math.sign(a)*Math.abs(o/e)),n.x=t.x+o,n.y=t.y+a}(o,t.chartArea.width/t.chartArea.height)}return o}function K(t,n,e,o){const a=r(n,"x",t),i=r(n,"y",t),{top:c,left:s,right:l,bottom:m,width:u,height:d}=t.chartArea,f={top:c,left:s,right:l,bottom:m},p=B(t,e,o&&a&&i);a&&X(f,t.chartArea,p,{min:"left",max:"right",prop:"x"}),i&&X(f,t.chartArea,p,{min:"top",max:"bottom",prop:"y"});const h=f.right-f.left,g=f.bottom-f.top;return{...f,width:h,height:g,zoomX:a&&h?1+(u-h)/u:1,zoomY:i&&g?1+(d-g)/d:1}}function W(t,n){const o=m(t);if(!o.dragStart)return;N(t,"mousemove");const{mode:a,onZoomComplete:i,drag:{threshold:c=0,maintainAspectRatio:s}}=o.options.zoom,l=K(t,a,{dragStart:o.dragStart,dragEnd:n},s),u=r(a,"x",t)?l.width:0,d=r(a,"y",t)?l.height:0,f=Math.sqrt(u*u+d*d);if(o.dragStart=o.dragEnd=null,f<=c)return o.dragging=!1,void t.update("none");Z(t,{x:l.left,y:l.top},{x:l.right,y:l.bottom},"zoom","drag"),o.dragging=!1,o.filterNextClick=!0,e.callback(i,[{chart:t}])}function I(t,n){const{handlers:{onZoomComplete:a},options:{zoom:r}}=m(t);if(!function(t,n,a){if(i(o(a.wheel),n))e.callback(a.onZoomRejected,[{chart:t,event:n}]);else if(!1!==q(t,n,a)&&(n.cancelable&&n.preventDefault(),void 0!==n.deltaY))return!0}(t,n,r))return;const c=n.target.getBoundingClientRect(),s=r.wheel.speed,l=n.deltaY>=0?2-1/(1-s):1+s;C(t,{x:l,y:l,focalPoint:{x:n.clientX-c.left,y:n.clientY-c.top}},"zoom","wheel"),e.callback(a,[{chart:t}])}function U(t,n,o,a){o&&(m(t).handlers[n]=function(t,n){let e;return function(){return clearTimeout(e),e=setTimeout(t,n),n}}((()=>e.callback(o,[{chart:t}])),a))}function _(t,n){return function(r,c){const{pan:s,zoom:l={}}=n.options;if(!s||!s.enabled)return!1;const m=c&&c.srcEvent;return!m||(!(!n.panning&&"mouse"===c.pointerType&&(i(o(s),m)||a(o(l.drag),m)))||(e.callback(s.onPanRejected,[{chart:t,event:c}]),!1))}}function G(t,n,e){if(n.scale){const{center:o,pointers:a}=e,i=1/n.scale*e.scale,c=e.target.getBoundingClientRect(),s=function(t,n){const e=Math.abs(t.clientX-n.clientX),o=Math.abs(t.clientY-n.clientY),a=e/o;let i,r;return a>.3&&a<1.7?i=r=!0:e>o?i=!0:r=!0,{x:i,y:r}}(a[0],a[1]),l=n.options.zoom.mode;C(t,{x:s.x&&r(l,"x",t)?i:1,y:s.y&&r(l,"y",t)?i:1,focalPoint:{x:o.x-c.left,y:o.y-c.top}},"zoom","pinch"),n.scale=e.scale}}function J(t,n,e){const o=n.delta;o&&(n.panning=!0,O(t,{x:e.deltaX-o.x,y:e.deltaY-o.y},n.panScales),n.delta={x:e.deltaX,y:e.deltaY})}const Q=new WeakMap;function $(t,o){const a=m(t),i=t.canvas,{pan:r,zoom:c}=o,l=new n.Manager(i);c&&c.pinch.enabled&&(l.add(new n.Pinch),l.on("pinchstart",(n=>function(t,n,o){if(n.options.zoom.pinch.enabled){const a=e.getRelativePosition(o,t);!1===e.callback(n.options.zoom.onZoomStart,[{chart:t,event:o,point:a}])?(n.scale=null,e.callback(n.options.zoom.onZoomRejected,[{chart:t,event:o}])):n.scale=1}}(t,a,n))),l.on("pinch",(n=>G(t,a,n))),l.on("pinchend",(n=>function(t,n,o){n.scale&&(G(t,n,o),n.scale=null,e.callback(n.options.zoom.onZoomComplete,[{chart:t}]))}(t,a,n)))),r&&r.enabled&&(l.add(new n.Pan({threshold:r.threshold,enable:_(t,a)})),l.on("panstart",(n=>function(t,n,o){const{enabled:a,onPanStart:i,onPanRejected:r}=n.options.pan;if(!a)return;const c=o.target.getBoundingClientRect(),l={x:o.center.x-c.left,y:o.center.y-c.top};if(!1===e.callback(i,[{chart:t,event:o,point:l}]))return e.callback(r,[{chart:t,event:o}]);n.panScales=s(n.options.pan,l,t),n.delta={x:0,y:0},J(t,n,o)}(t,a,n))),l.on("panmove",(n=>J(t,a,n))),l.on("panend",(()=>function(t,n){n.delta=null,n.panning&&(n.panning=!1,n.filterNextClick=!0,e.callback(n.options.pan.onPanComplete,[{chart:t}]))}(t,a)))),Q.set(t,l)}function tt(t){const n=Q.get(t);n&&(n.remove("pinchstart"),n.remove("pinch"),n.remove("pinchend"),n.remove("panstart"),n.remove("pan"),n.remove("panend"),n.destroy(),Q.delete(t))}function nt(t,n,e){const o=e.zoom.drag,{dragStart:a,dragEnd:i}=m(t);if(o.drawTime!==n||!i)return;const{left:r,top:c,width:s,height:l}=K(t,e.zoom.mode,{dragStart:a,dragEnd:i},o.maintainAspectRatio),u=t.ctx;u.save(),u.beginPath(),u.fillStyle=o.backgroundColor||"rgba(225,225,225,0.3)",u.fillRect(r,c,s,l),o.borderWidth>0&&(u.lineWidth=o.borderWidth,u.strokeStyle=o.borderColor||"rgba(225,225,225)",u.strokeRect(r,c,s,l)),u.restore()}var et={id:"zoom",version:"2.2.0",defaults:{pan:{enabled:!1,mode:"xy",threshold:10,modifierKey:null},zoom:{wheel:{enabled:!1,speed:.1,modifierKey:null},drag:{enabled:!1,drawTime:"beforeDatasetsDraw",modifierKey:null},pinch:{enabled:!1},mode:"xy"}},start:function(t,o,a){m(t).options=a,Object.prototype.hasOwnProperty.call(a.zoom,"enabled")&&console.warn("The option `zoom.enabled` is no longer supported. Please use `zoom.wheel.enabled`, `zoom.drag.enabled`, or `zoom.pinch.enabled`."),(Object.prototype.hasOwnProperty.call(a.zoom,"overScaleMode")||Object.prototype.hasOwnProperty.call(a.pan,"overScaleMode"))&&console.warn("The option `overScaleMode` is deprecated. Please use `scaleMode` instead (and update `mode` as desired)."),n&&$(t,a),t.pan=(n,e,o)=>O(t,n,e,o),t.zoom=(n,e)=>C(t,n,e),t.zoomRect=(n,e,o)=>Z(t,n,e,o),t.zoomScale=(n,o,a)=>function(t,n,o,a="none",i="api"){const r=m(t);k(t,r),h(t.scales[n],o,void 0,!0),t.update(a),e.callback(r.options.zoom?.onZoom,[{chart:t,trigger:i}])}(t,n,o,a),t.resetZoom=n=>function(t,n="default"){const o=m(t),a=k(t,o);e.each(t.scales,(function(t){const n=t.options;a[t.id]?(n.min=a[t.id].min.options,n.max=a[t.id].max.options):(delete n.min,delete n.max),delete o.updatedScaleLimits[t.id]})),t.update(n),e.callback(o.options.zoom.onZoomComplete,[{chart:t}])}(t,n),t.getZoomLevel=()=>j(t),t.getInitialScaleBounds=()=>R(t),t.getZoomedScaleBounds=()=>function(t){const n=m(t),e={};for(const o of Object.keys(t.scales))e[o]=n.updatedScaleLimits[o];return e}(t),t.isZoomedOrPanned=()=>function(t){const n=R(t);for(const e of Object.keys(t.scales)){const{min:o,max:a}=n[e];if(void 0!==o&&t.scales[e].min!==o)return!0;if(void 0!==a&&t.scales[e].max!==a)return!0}return!1}(t),t.isZoomingOrPanning=()=>E(t)},beforeEvent(t,{event:n}){if(E(t))return!1;if("click"===n.type||"mouseup"===n.type){const n=m(t);if(n.filterNextClick)return n.filterNextClick=!1,!1}},beforeUpdate:function(t,n,e){const o=m(t),a=o.options;o.options=e,function(t,n){const{pan:e,zoom:o}=t,{pan:a,zoom:i}=n;return o?.zoom?.pinch?.enabled!==i?.zoom?.pinch?.enabled||e?.enabled!==a?.enabled||e?.threshold!==a?.threshold}(a,e)&&(tt(t),$(t,e)),function(t,n){const e=t.canvas,{wheel:o,drag:a,onZoomComplete:i}=n.zoom;o.enabled?(A(t,e,"wheel",I),U(t,"onZoomComplete",i,250)):N(t,"wheel"),a.enabled?(A(t,e,"mousedown",V),A(t,e.ownerDocument,"mouseup",W)):(N(t,"mousedown"),N(t,"mousemove"),N(t,"mouseup"),N(t,"keydown"))}(t,e)},beforeDatasetsDraw(t,n,e){nt(t,"beforeDatasetsDraw",e)},afterDatasetsDraw(t,n,e){nt(t,"afterDatasetsDraw",e)},beforeDraw(t,n,e){nt(t,"beforeDraw",e)},afterDraw(t,n,e){nt(t,"afterDraw",e)},stop:function(t){!function(t){N(t,"mousedown"),N(t,"mousemove"),N(t,"mouseup"),N(t,"wheel"),N(t,"click"),N(t,"keydown")}(t),n&&tt(t),function(t){l.delete(t)}(t)},panFunctions:z,zoomFunctions:v,zoomRectFunctions:w};return t.Chart.register(et),et}));
diff --git a/benchmarks-website/server/static/icon-dark.png b/benchmarks-website/server/static/icon-dark.png
deleted file mode 100644
index 8406c62a317..00000000000
Binary files a/benchmarks-website/server/static/icon-dark.png and /dev/null differ
diff --git a/benchmarks-website/server/static/icon-light.png b/benchmarks-website/server/static/icon-light.png
deleted file mode 100644
index 4e90ee0d395..00000000000
Binary files a/benchmarks-website/server/static/icon-light.png and /dev/null differ
diff --git a/benchmarks-website/server/static/style.css b/benchmarks-website/server/static/style.css
deleted file mode 100644
index 710d1f68f89..00000000000
--- a/benchmarks-website/server/static/style.css
+++ /dev/null
@@ -1,1311 +0,0 @@
-/* SPDX-License-Identifier: Apache-2.0 */
-/* SPDX-FileCopyrightText: Copyright the Vortex contributors */
-
-:root {
-  color-scheme: light;
-  --header-height: 72px;
-  --bg: #ffffff;
-  --page-bg: #fafafa;
-  --fg: #101010;
-  --muted: #666666;
-  --accent: #5971fd;
-  --accent-fg: #ffffff;
-  --border: #ececec;
-  --card-bg: #ffffff;
-  --code-bg: #fafafa;
-  --tooltip-bg: #1a1a1a;
-  --tooltip-fg: #f5f5f5;
-  --good: #16a34a;
-  --bad: #dc2626;
-  --shadow-md: 0 4px 8px rgba(16, 16, 16, 0.08);
-}
-
-@media (prefers-color-scheme: dark) {
-  :root {
-    color-scheme: dark;
-    /* Elevation hierarchy mirrors v2: page background sits at the
-     * deeper colour, cards / dropdowns / toolbars rise to the lighter
-     * grey. The previous assignment had cards darker than the page,
-     * which read as overly contrasty dark voids on the landing grid. */
-    --bg: #121219;
-    --page-bg: #050507;
-    --fg: #f5f5f7;
-    --muted: #a0a0b0;
-    --accent: #8a9cff;
-    --accent-fg: #050507;
-    --border: #30303a;
-    --card-bg: #121219;
-    --code-bg: #050507;
-    --tooltip-bg: #1a1c22;
-    --tooltip-fg: #f5f5f5;
-    --good: #4ade80;
-    --bad: #f87171;
-    --shadow-md: 0 4px 8px rgba(0, 0, 0, 0.7);
-  }
-}
-
-:root[data-theme="light"] {
-  color-scheme: light;
-  --bg: #ffffff;
-  --page-bg: #fafafa;
-  --fg: #101010;
-  --muted: #666666;
-  --accent: #5971fd;
-  --accent-fg: #ffffff;
-  --border: #ececec;
-  --card-bg: #ffffff;
-  --code-bg: #fafafa;
-  --tooltip-bg: #1a1a1a;
-  --tooltip-fg: #f5f5f5;
-  --good: #16a34a;
-  --bad: #dc2626;
-  --shadow-md: 0 4px 8px rgba(16, 16, 16, 0.08);
-}
-
-:root[data-theme="dark"] {
-  color-scheme: dark;
-  /* See the matching `@media (prefers-color-scheme: dark)` block above
-   * for the rationale on the --bg / --page-bg / --card-bg assignment. */
-  --bg: #121219;
-  --page-bg: #050507;
-  --fg: #f5f5f7;
-  --muted: #a0a0b0;
-  --accent: #8a9cff;
-  --accent-fg: #050507;
-  --border: #30303a;
-  --card-bg: #121219;
-  --code-bg: #050507;
-  --tooltip-bg: #1a1c22;
-  --tooltip-fg: #f5f5f5;
-  --good: #4ade80;
-  --bad: #f87171;
-  --shadow-md: 0 4px 8px rgba(0, 0, 0, 0.7);
-}
-
-* { box-sizing: border-box; }
-
-html, body {
-  margin: 0;
-  padding: 0;
-  width: 100%;
-  min-width: 0;
-  overflow-x: hidden;
-  background: var(--page-bg);
-  color: var(--fg);
-  /* Geist is loaded from unpkg by `html::render::web_font_links`; the
-   * fallback stack matches v2's `src/styles/index.css` so the site
-   * remains legible if the CDN is blocked. */
-  font-family: "Geist", -apple-system, BlinkMacSystemFont, "Segoe UI",
-    "SF Pro Display", Roboto, sans-serif;
-  font-size: 16px;
-  line-height: 1.6;
-}
-
-/* All headings use Funnel Display, mirroring v2's
- * `h1, h2, h3, h4, h5, h6` rule. Loaded from Google Fonts by
- * `html::render::web_font_links`. */
-h1, h2, h3, h4, h5, h6 {
-  font-family: "Funnel Display", sans-serif;
-  letter-spacing: -0.02em;
-}
-
-/* Code blocks use Geist Mono, mirroring v2's `code, pre` rule. The
- * fallback stack matches what the explicit-mono usages further down
- * declare so a CDN-blocked client still gets a monospace font. */
-code, pre {
-  font-family: "Geist Mono", ui-monospace, "SFMono-Regular", Menlo,
-    Consolas, monospace;
-}
-
-body {
-  padding-top: var(--header-height);
-}
-
-a { color: var(--accent); text-decoration: none; }
-a:hover { text-decoration: underline; }
-
-.sticky-header {
-  position: fixed;
-  top: 0;
-  left: 0;
-  right: 0;
-  z-index: 1000;
-  height: var(--header-height);
-  border-bottom: 1px solid var(--border);
-  background: rgba(250, 250, 250, 0.95);
-  box-shadow: 0 1px 3px rgba(16, 16, 16, 0.08);
-  backdrop-filter: blur(10px);
-  -webkit-backdrop-filter: blur(10px);
-}
-
-@media (prefers-color-scheme: dark) {
-  :root:not([data-theme="light"]) .sticky-header {
-    background: rgba(18, 18, 25, 0.95);
-    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.6);
-  }
-}
-
-:root[data-theme="dark"] .sticky-header {
-  background: rgba(18, 18, 25, 0.95);
-  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.6);
-}
-
-:root[data-theme="light"] .sticky-header {
-  background: rgba(250, 250, 250, 0.95);
-  box-shadow: 0 1px 3px rgba(16, 16, 16, 0.08);
-}
-
-.header-content {
-  /* Sticky-header inner background. v2 maps this to `--bg-secondary`,
-   * the elevated grey in dark mode (`#121219`); v3's `--bg` resolves
-   * to the same colour. Using `--code-bg` here flattened the header
-   * against the page in dark mode. */
-  background: var(--bg);
-  position: relative;
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 1.5rem;
-  width: 100%;
-  height: 100%;
-  padding: 0 2rem;
-}
-
-.header-left,
-.header-center,
-.header-right,
-.nav-controls,
-.repo-link,
-.logo-link {
-  display: flex;
-  align-items: center;
-}
-
-.header-left {
-  min-width: 0;
-  gap: 0.75rem;
-}
-
-.header-center {
-  position: absolute;
-  left: 50%;
-  top: 50%;
-  flex: 0 0 auto;
-  justify-content: center;
-  min-width: 0;
-  transform: translate(-50%, -50%);
-}
-
-.header-right {
-  justify-content: flex-end;
-  gap: 0.75rem;
-  margin-left: auto;
-}
-
-.nav-controls {
-  gap: 0.75rem;
-  min-width: 0;
-}
-
-/* Hamburger button + the mobile-only GitHub link inside `.nav-controls`
- * are hidden by default; the mobile media query below flips them on. The
- * compound selector beats `.control-btn` / `.repo-link` on specificity so
- * those generic display rules don't accidentally re-show them on desktop. */
-.header-left .nav-mobile-toggle { display: none; }
-.nav-controls .nav-controls-github { display: none; }
-
-.logo-link {
-  flex: 0 0 auto;
-  text-decoration: none;
-  transition: opacity 0.2s ease;
-}
-
-.logo-link:hover {
-  opacity: 0.8;
-  text-decoration: none;
-}
-
-.site-logo {
-  display: block;
-  width: auto;
-  height: 24px;
-}
-
-.logo-dark { display: none; }
-
-@media (prefers-color-scheme: dark) {
-  :root:not([data-theme="light"]) .logo-light { display: none; }
-  :root:not([data-theme="light"]) .logo-dark { display: block; }
-}
-
-:root[data-theme="dark"] .logo-light { display: none; }
-:root[data-theme="dark"] .logo-dark { display: block; }
-:root[data-theme="light"] .logo-light { display: block; }
-:root[data-theme="light"] .logo-dark { display: none; }
-
-.site-title {
-  display: none;
-  margin: 0 0 0 1.5rem;
-  color: var(--fg);
-  font-size: 1.5rem;
-  font-weight: 500;
-  line-height: 1.2;
-  white-space: nowrap;
-}
-
-@media (min-width: 1400px) {
-  .site-title {
-    display: block;
-  }
-}
-
-.control-btn,
-.repo-link {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  gap: 0.45rem;
-  min-height: 36px;
-  border: 1px solid var(--border);
-  border-radius: 8px;
-  background: var(--bg);
-  color: var(--fg);
-  font: inherit;
-  font-size: 0.875rem;
-  font-weight: 500;
-  line-height: 1;
-  white-space: nowrap;
-  transition: background-color 0.2s ease, border-color 0.2s ease,
-    box-shadow 0.2s ease, color 0.2s ease, transform 0.2s ease;
-}
-
-.control-btn {
-  padding: 0.5rem 1.25rem;
-  cursor: pointer;
-}
-
-.control-btn:hover,
-.repo-link:hover {
-  border-color: var(--accent);
-  background: var(--code-bg);
-  color: var(--accent);
-  box-shadow: 0 1px 3px rgba(16, 16, 16, 0.08);
-  text-decoration: none;
-  transform: translateY(-1px);
-}
-
-.theme-toggle {
-  min-width: 4.25rem;
-}
-
-.btn-icon {
-  flex: 0 0 auto;
-}
-
-.theme-icon-dark {
-  display: none;
-}
-
-.theme-toggle[data-next-theme="dark"] .theme-icon-light {
-  display: none;
-}
-
-.theme-toggle[data-next-theme="dark"] .theme-icon-dark {
-  display: block;
-}
-
-.theme-toggle[data-next-theme="light"] .theme-icon-light {
-  display: block;
-}
-
-.theme-toggle[data-next-theme="light"] .theme-icon-dark {
-  display: none;
-}
-
-.repo-link {
-  padding: 0.5rem 1rem;
-  font-weight: 500;
-}
-
-.github-logo {
-  flex: 0 0 auto;
-}
-
-.page-header {
-  border-bottom: 1px solid var(--border);
-  background: var(--code-bg);
-  padding: 1rem 2rem;
-  width: 100%;
-}
-.page-header h1 { margin: 0; font-size: 1.25rem; font-weight: 600; }
-.page-header h1 a { color: var(--fg); }
-.page-header .subtitle {
-  margin: 0.25rem 0 0;
-  color: var(--muted);
-  font-size: 0.875rem;
-}
-
-main {
-  width: 100%;
-  max-width: none;
-  margin: 0;
-  padding: 2rem;
-}
-
-@media (min-width: 1600px) {
-  main { padding: 2.5rem 3.75rem; }
-}
-
-@media (min-width: 1920px) {
-  main { padding: 3rem 5rem; }
-}
-
-.empty {
-  color: var(--muted);
-  font-style: italic;
-}
-
-.group-details {
-  width: 100%;
-  max-width: none;
-  margin-bottom: 3rem;
-  border: 1px solid var(--border);
-  border-radius: 12px;
-  background: var(--bg);
-  overflow: hidden;
-  transition: border-color 0.2s ease, box-shadow 0.2s ease;
-}
-.group-disclosure {
-  display: block;
-}
-.group-summary {
-  list-style: none;
-  cursor: pointer;
-  display: block;
-  /* Elevated surface - v2's `.benchmark-header` uses `--bg-secondary`
-   * (`#121219` in dark mode); `--card-bg` is the v3 alias for that
-   * elevated colour. Using `--code-bg` here flattened the disclosure
-   * bar against the page in dark mode. */
-  background: var(--card-bg);
-  border-radius: 12px 12px 0 0;
-  user-select: none;
-}
-.group-summary-row {
-  display: flex;
-  align-items: center;
-  gap: 0.75rem;
-  padding: 1rem 2rem;
-  border-bottom: 1px solid var(--border);
-  transition: background-color 0.2s ease;
-}
-.group-summary::-webkit-details-marker { display: none; }
-.group-summary-row::before {
-  content: "▶";
-  display: inline-block;
-  width: 1rem;
-  flex: 0 0 auto;
-  font-size: 0.9rem;
-  line-height: 1;
-  text-align: center;
-  color: var(--muted);
-  transition: transform 120ms ease;
-}
-.group-disclosure[open] > .group-summary .group-summary-row::before {
-  transform: rotate(90deg);
-}
-.group-summary:hover .group-summary-row { background: var(--bg); }
-.group-name {
-  /* `.group-name` is a `<span>` in `landing.rs`, so it doesn't inherit
-   * from the `h1, h2, ..., h6` rule. v2's `.benchmark-title` applies
-   * Funnel Display explicitly; mirror that here. */
-  font-family: "Funnel Display", sans-serif;
-  font-weight: 600;
-  font-size: 1.35rem;
-  line-height: 1.2;
-  letter-spacing: -0.02em;
-}
-.group-count {
-  color: var(--muted);
-  font-family: "Geist Mono", ui-monospace, "SFMono-Regular", Menlo, Consolas, monospace;
-  font-size: 0.7rem;
-  font-weight: 600;
-  font-variant-numeric: tabular-nums;
-  letter-spacing: 0.02em;
-  line-height: 1;
-  text-transform: uppercase;
-}
-/*
- * The small ⓘ next to a group title that surfaces the editorial blurb on
- * hover and on focus. The icon is keyboard-focusable; clicking the icon
- * doesn't toggle the surrounding `<details>` because we stop propagation
- * via `pointer-events: auto` on the icon (the surrounding summary row is
- * still clickable around it).
- */
-.group-info-icon {
-  position: relative;
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  width: 1.25rem;
-  height: 1.25rem;
-  border-radius: 50%;
-  font-size: 0.95rem;
-  line-height: 1;
-  color: var(--muted);
-  cursor: help;
-  user-select: none;
-  flex-shrink: 0;
-  transition: color 0.15s ease;
-}
-.group-info-icon:hover,
-.group-info-icon:focus-visible {
-  color: var(--fg);
-  outline: none;
-}
-/*
- * CSS-only tooltip rendered below the icon. We use a `::after` pseudo so
- * we don't have to plant extra DOM. `pointer-events: none` keeps the
- * tooltip from intercepting hover (which would cause flicker), and
- * `white-space: normal` + a fixed `max-width` lets long descriptions wrap
- * gracefully.
- *
- * Anchored to the icon's left edge (not centred on the icon) so the tooltip
- * grows rightward into the page. Group titles in our layout are left-
- * aligned in the disclosure header, so the icon is always close to the
- * viewport's left edge - `left: 50%; transform: translateX(-50%)` would
- * push half of a wide tooltip off the screen and clip it. Anchoring to the
- * left keeps the description fully visible.
- */
-[data-tooltip].group-info-icon::after {
-  content: attr(data-tooltip);
-  position: absolute;
-  top: calc(100% + 0.5rem);
-  left: 0;
-  padding: 0.5rem 0.75rem;
-  background: var(--tooltip-bg);
-  color: var(--tooltip-fg);
-  font-size: 0.8rem;
-  font-weight: 400;
-  line-height: 1.35;
-  border-radius: 6px;
-  max-width: min(28rem, 90vw);
-  width: max-content;
-  white-space: normal;
-  text-align: left;
-  opacity: 0;
-  visibility: hidden;
-  transition: opacity 0.15s ease, visibility 0.15s ease;
-  pointer-events: none;
-  z-index: 10;
-  box-shadow: 0 4px 14px rgba(0, 0, 0, 0.18);
-}
-[data-tooltip].group-info-icon:hover::after,
-[data-tooltip].group-info-icon:focus-visible::after {
-  opacity: 1;
-  visibility: visible;
-}
-.group-details > .chart-grid {
-  padding: 1.25rem;
-  /* Page-level surface behind the chart cards. v2's `.benchmark-graphs`
-   * uses `--bg-color` (`#050507` in dark mode); `--page-bg` is the v3
-   * alias for the page colour. Using `--bg` here made the grid behind
-   * cards appear lighter than the body, inverting v2's elevation. */
-  background: var(--page-bg);
-}
-
-.benchmark-scores-summary {
-  border-bottom: 1px solid var(--border);
-  /* Elevated surface, same role as v2's `.benchmark-scores-summary`
-   * which uses `--bg-secondary`. */
-  background: var(--card-bg);
-  padding: 0.75rem 2rem;
-  margin: 0;
-}
-
-.group-disclosure:not([open]) ~ .chart-grid {
-  display: none;
-}
-
-/*
- * During the post-load Chart.js prebuild, render closed groups' chart
- * grids in a hidden offscreen position so each canvas has real layout
- * dimensions for Chart.js to measure. Without this override, charts
- * construct against a 0x0 parent (the closed-group rule above), and the
- * eventual on-toggle resize leaves a brief flash of a blank, full-zoomed
- * canvas before the next frame paints. The width matches the visible
- * content area via `--bench-prebuild-width` (set by `chart-init.js` from
- * the live `<main>` width) so the build dimensions are close enough to
- * the actual on-screen dimensions that Chart.js's ResizeObserver-driven
- * adjust on toggle is a no-op or a single sub-frame tick.
- */
-body.bench-prebuilding .group-disclosure:not([open]) ~ .chart-grid {
-  display: grid !important;
-  position: fixed !important;
-  visibility: hidden !important;
-  pointer-events: none !important;
-  top: -10000px !important;
-  left: 0 !important;
-  width: var(--bench-prebuild-width, 100vw);
-}
-
-.group-details > .chart-grid .chart-card:last-child {
-  margin-bottom: 0;
-}
-
-.chart-meta + .benchmark-scores-summary {
-  border: 1px solid var(--border);
-  border-radius: 8px;
-  margin-bottom: 1rem;
-}
-
-.scores-title {
-  margin: 0 0 0.5rem;
-  color: var(--muted);
-  font-size: 0.75rem;
-  font-weight: 600;
-  text-transform: uppercase;
-  letter-spacing: 0.04em;
-}
-
-.scores-list {
-  column-count: 2;
-  column-gap: 1.25rem;
-}
-
-.score-item {
-  display: flex;
-  align-items: center;
-  gap: 0.5rem;
-  padding: 0.25rem 0;
-  font-size: 0.875rem;
-  break-inside: avoid;
-}
-
-.score-rank {
-  min-width: 2.25rem;
-  color: var(--accent);
-  font-size: 0.75rem;
-  font-weight: 600;
-  text-transform: uppercase;
-  font-variant-numeric: tabular-nums;
-}
-
-.score-series {
-  min-width: 0;
-  flex: 1;
-  overflow: hidden;
-  color: var(--fg);
-  font-weight: 500;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-.score-metrics {
-  display: inline-flex;
-  align-items: baseline;
-  gap: 0.4rem;
-  font-variant-numeric: tabular-nums;
-  white-space: nowrap;
-}
-
-.score-value,
-.score-runtime {
-  font-family: "Geist Mono", ui-monospace, "SFMono-Regular", Menlo, Consolas, monospace;
-  font-size: 0.8rem;
-  font-weight: 600;
-}
-
-.score-value { color: var(--accent); }
-.score-runtime { color: var(--muted); }
-
-.scores-explanation {
-  margin-top: 0.45rem;
-  color: var(--muted);
-  font-size: 0.72rem;
-  font-style: italic;
-  text-align: center;
-}
-
-/* ----------------------------------------------------------------------
- * Global filter dropdown - lives inside the sticky header. The trigger is
- * a `.control-btn` styled like the expand/collapse buttons; the panel is
- * absolutely positioned beneath it and shows two rows of `.filter-chip`
- * buttons that toggle whole engines / formats across every chart at once.
- *
- * Toggle semantics (driven by chart-init.js):
- *   - Each non-"all" chip toggles independently. Active = visible.
- *   - The "all" chip is a one-shot reset; clicking it forces every chip
- *     in that row back to active. It never holds an active state itself.
- *   - Per-chart legend clicks override the global state for that card.
- * ---------------------------------------------------------------------- */
-.filter-dropdown {
-  position: relative;
-  display: inline-flex;
-  align-items: center;
-}
-.filter-trigger {
-  position: relative;
-}
-.filter-badge {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  min-width: 1.25rem;
-  height: 1.25rem;
-  padding: 0 0.4rem;
-  border-radius: 999px;
-  background: var(--accent);
-  color: var(--accent-fg);
-  font-size: 0.7rem;
-  font-weight: 600;
-  line-height: 1;
-}
-.filter-panel {
-  position: absolute;
-  top: calc(100% + 0.5rem);
-  left: 50%;
-  transform: translateX(-50%);
-  z-index: 1100;
-  display: flex;
-  flex-direction: column;
-  gap: 0.5rem;
-  min-width: 22rem;
-  max-width: min(90vw, 36rem);
-  padding: 0.75rem 0.85rem;
-  border: 1px solid var(--border);
-  border-radius: 8px;
-  background: var(--card-bg);
-  box-shadow: var(--shadow-md);
-}
-.filter-panel[hidden] { display: none; }
-.global-filter-row {
-  display: flex;
-  flex-wrap: wrap;
-  align-items: center;
-  gap: 0.35rem;
-}
-.global-filter-label {
-  flex: 0 0 auto;
-  min-width: 4rem;
-  color: var(--muted);
-  font-size: 0.7rem;
-  text-transform: uppercase;
-  letter-spacing: 0.04em;
-}
-.filter-chip {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  min-height: 24px;
-  padding: 0.1rem 0.6rem;
-  border: 1px solid var(--border);
-  border-radius: 999px;
-  background: var(--bg);
-  color: var(--fg);
-  font-size: 0.78rem;
-  font-family: inherit;
-  cursor: pointer;
-}
-.filter-chip:hover { border-color: var(--accent); }
-.filter-chip--active {
-  background: var(--accent);
-  border-color: var(--accent);
-  color: var(--accent-fg);
-}
-.filter-chip--all {
-  font-weight: 500;
-}
-
-/* ----------------------------------------------------------------------
- * Per-chart toolbar (`.toolbar.toolbar--card`)
- * ---------------------------------------------------------------------- */
-.toolbar--card {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 0.4rem 0.75rem;
-  align-items: center;
-  padding: 0.4rem 0.5rem;
-  margin-bottom: 0.5rem;
-  border: 1px solid var(--border);
-  border-radius: 4px;
-  background: var(--bg);
-  font-size: 0.78rem;
-}
-.toolbar-group {
-  display: flex;
-  flex-wrap: wrap;
-  align-items: center;
-  gap: 0.25rem;
-}
-.toolbar-label {
-  color: var(--muted);
-  font-size: 0.7rem;
-  text-transform: uppercase;
-  letter-spacing: 0.04em;
-  margin-right: 0.15rem;
-}
-.toolbar-btn {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  min-height: 24px;
-  padding: 0.1rem 0.5rem;
-  border: 1px solid var(--border);
-  border-radius: 3px;
-  background: var(--bg);
-  color: var(--fg);
-  font-size: 0.78rem;
-  font-family: inherit;
-  cursor: pointer;
-  text-decoration: none;
-}
-.toolbar-btn:hover { border-color: var(--accent); }
-.toolbar-btn--active {
-  background: var(--accent);
-  border-color: var(--accent);
-  color: var(--accent-fg);
-}
-.toolbar-btn--active:hover { color: var(--accent-fg); }
-.toolbar-slider {
-  width: 12rem;
-  accent-color: var(--accent);
-}
-
-/* ----------------------------------------------------------------------
- * Per-group toolbar - sits between the group's score summary and the
- * chart grid. Y-axis buttons on the left, a centered "Filter series"
- * dropdown trigger, and a Reset button on the right. The dropdown panel
- * holds engine/format macro chips and a series row populated by JS as
- * charts in the group hydrate. Hidden alongside `.chart-grid` when the
- * disclosure is closed via the same `:not([open]) ~` rule.
- * ---------------------------------------------------------------------- */
-.group-toolbar {
-  display: flex;
-  flex-wrap: wrap;
-  align-items: center;
-  gap: 0.35rem 0.75rem;
-  padding: 0.4rem 1.25rem;
-  border-bottom: 1px solid var(--border);
-  background: var(--bg);
-  font-size: 0.78rem;
-}
-.group-disclosure:not([open]) ~ .group-toolbar {
-  display: none;
-}
-.group-toolbar-y {
-  flex: 0 0 auto;
-  gap: 0.25rem;
-}
-.group-filter-dropdown {
-  position: relative;
-  flex: 1 1 auto;
-  display: flex;
-  justify-content: center;
-}
-.group-filter-trigger {
-  min-height: 28px;
-  padding: 0.25rem 0.85rem;
-  font-size: 0.78rem;
-}
-.group-filter-panel {
-  position: absolute;
-  top: calc(100% + 0.5rem);
-  left: 50%;
-  transform: translateX(-50%);
-  z-index: 1000;
-  display: flex;
-  flex-direction: column;
-  gap: 0.6rem;
-  min-width: 24rem;
-  max-width: min(90vw, 42rem);
-  padding: 0.75rem 0.85rem;
-  border: 1px solid var(--border);
-  border-radius: 8px;
-  background: var(--card-bg);
-  box-shadow: var(--shadow-md);
-}
-.group-filter-panel[hidden] { display: none; }
-.group-series-row { align-items: flex-start; }
-.group-series-chips {
-  display: flex;
-  flex-wrap: wrap;
-  align-items: center;
-  gap: 0.35rem;
-  flex: 1 1 auto;
-  min-width: 0;
-}
-.group-toolbar-reset {
-  flex: 0 0 auto;
-  display: inline-flex;
-  align-items: center;
-  min-height: 24px;
-  padding: 0.1rem 0.6rem;
-  border: 1px solid var(--border);
-  border-radius: 3px;
-  background: var(--bg);
-  color: var(--muted);
-  font: inherit;
-  font-size: 0.78rem;
-  cursor: pointer;
-}
-.group-toolbar-reset:hover {
-  border-color: var(--accent);
-  color: var(--accent);
-}
-
-/* ----------------------------------------------------------------------
- * Single-chart + group-page chart card
- * ---------------------------------------------------------------------- */
-.chart-meta {
-  color: var(--muted);
-  font-size: 0.875rem;
-  margin: 0 0 0.75rem;
-}
-.chart-meta code {
-  background: var(--code-bg);
-  padding: 0.1rem 0.35rem;
-  border-radius: 3px;
-  font-size: 0.85em;
-}
-
-.chart-card {
-  min-width: 0;
-  width: 100%;
-  max-width: none;
-  position: relative;
-  border: 1px solid var(--border);
-  border-radius: 8px;
-  background: var(--card-bg);
-  padding: 1.25rem;
-  margin-bottom: 1rem;
-  transition: box-shadow 0.2s ease;
-}
-.chart-card:hover {
-  box-shadow: var(--shadow-md);
-}
-.chart-card-title {
-  margin: 0 0 0.4rem;
-  font-size: 0.95rem;
-  font-weight: 500;
-  display: flex;
-  align-items: baseline;
-  gap: 0.5rem;
-  flex-wrap: wrap;
-}
-.chart-card-title a { color: var(--fg); }
-.chart-card-title a:hover { color: var(--accent); }
-
-/* Downsampled-payload badge. Rendered both server-side (when the inline
- * payload was downsampled) and client-side (after the lazy fetch
- * completes). The `hidden` attribute hides it when no downsampling
- * occurred; JS toggles it via `removeAttribute("hidden")`. */
-.chart-badge {
-  font-size: 0.7rem;
-  font-weight: 500;
-  letter-spacing: 0.02em;
-  padding: 0.1rem 0.45rem;
-  border-radius: 999px;
-  background: var(--code-bg);
-  color: var(--muted);
-  border: 1px solid var(--border);
-  white-space: nowrap;
-  cursor: help;
-}
-.chart-badge[hidden] { display: none; }
-.chart-badge--downsampled {
-  background: color-mix(in srgb, var(--accent) 12%, transparent);
-  color: var(--accent);
-  border-color: color-mix(in srgb, var(--accent) 35%, transparent);
-}
-
-.chart-grid {
-  width: 100%;
-  max-width: none;
-  display: grid;
-  grid-template-columns: 1fr;
-  gap: 1rem;
-}
-
-.chart-wrap {
-  width: 100%;
-  position: relative;
-  height: 420px;
-}
-.chart-card .chart-wrap canvas,
-.chart-wrap canvas {
-  width: 100% !important;
-  height: 100% !important;
-}
-
-@media (min-width: 1200px) {
-  .chart-grid {
-    grid-template-columns: repeat(2, minmax(0, 1fr));
-    gap: 1.5rem;
-  }
-
-  .chart-wrap {
-    height: 450px;
-  }
-}
-
-/* Single-chart pages get a taller area; group cards keep the compact 450px. */
-main > .chart-card:not(.chart-grid .chart-card) .chart-wrap {
-  height: 680px;
-}
-
-/* ----------------------------------------------------------------------
- * Range scrollbar strip (`.chart-range-strip`)
- *
- * Thin track below each canvas. Spans the full commit history; the inset
- * `.chart-range-strip-window` highlights the currently visible slice and
- * carries two edge handles for resize. Pointer events are intentionally
- * `auto` (unlike the tooltip host) because users grab and drag this widget.
- * ---------------------------------------------------------------------- */
-.chart-range-strip {
-  position: relative;
-  width: 100%;
-  height: 14px;
-  margin-top: 0.4rem;
-  pointer-events: auto;
-  user-select: none;
-  touch-action: none;
-}
-.chart-range-strip-track {
-  position: absolute;
-  inset: 0;
-  background: var(--code-bg);
-  border: 1px solid var(--border);
-  border-radius: 3px;
-  overflow: hidden;
-}
-.chart-range-strip-window {
-  position: absolute;
-  top: 0;
-  bottom: 0;
-  left: 0;
-  width: 100%;
-  background: color-mix(in srgb, var(--accent) 28%, transparent);
-  border-left: 1px solid var(--accent);
-  border-right: 1px solid var(--accent);
-  cursor: grab;
-  box-sizing: border-box;
-}
-.chart-range-strip--dragging .chart-range-strip-window { cursor: grabbing; }
-.chart-range-strip-handle {
-  position: absolute;
-  top: 0;
-  bottom: 0;
-  width: 6px;
-  background: var(--accent);
-  cursor: ew-resize;
-}
-.chart-range-strip-handle--left { left: -3px; border-radius: 2px 0 0 2px; }
-.chart-range-strip-handle--right { right: -3px; border-radius: 0 2px 2px 0; }
-.chart-range-strip-handle:hover { filter: brightness(1.1); }
-
-@media (max-width: 768px) {
-  .chart-range-strip { height: 18px; }
-  .chart-range-strip-handle { width: 10px; }
-  .chart-range-strip-handle--left { left: -5px; }
-  .chart-range-strip-handle--right { right: -5px; }
-}
-
-.no-script {
-  margin-top: 1rem;
-  padding: 0.75rem 1rem;
-  border: 1px solid var(--border);
-  border-radius: 4px;
-  background: var(--code-bg);
-  color: var(--muted);
-  font-size: 0.875rem;
-}
-
-/* Per-card loading + error indicators (lazy-fetch on details toggle). */
-.chart-loading,
-.chart-error {
-  position: absolute;
-  top: 0.5rem;
-  right: 0.75rem;
-  font-size: 0.75rem;
-  padding: 0.15rem 0.5rem;
-  border-radius: 4px;
-  pointer-events: none;
-  z-index: 5;
-}
-.chart-loading {
-  background: var(--code-bg);
-  color: var(--muted);
-  border: 1px solid var(--border);
-}
-.chart-error {
-  background: var(--bad);
-  color: var(--accent-fg);
-  max-width: 18rem;
-  white-space: normal;
-}
-
-/* ----------------------------------------------------------------------
- * Custom external tooltip
- *
- * `pointer-events: none` is intentional and load-bearing: previously this
- * was flipped to `auto` while visible, which caused a flicker loop where
- * the cursor would land on the tooltip → mouseout fires on the canvas →
- * tooltip hides → cursor lands on the canvas → tooltip shows. The cost is
- * that links inside the tooltip are no longer clickable; the chart-card
- * title already links to the permalink.
- * ---------------------------------------------------------------------- */
-.chart-tooltip-host {
-  position: absolute;
-  top: 0;
-  left: 0;
-  pointer-events: none;
-  opacity: 0;
-  z-index: 20;
-  background: var(--tooltip-bg);
-  color: var(--tooltip-fg);
-  border-radius: 6px;
-  padding: 0.5rem 0.65rem;
-  font-size: 0.8rem;
-  line-height: 1.35;
-  max-width: 22rem;
-  box-shadow: 0 6px 20px rgba(0, 0, 0, 0.25);
-  /* default offset; chart-init.js flips horizontally near the right edge */
-  transform: translate(12px, 12px);
-  transition: opacity 80ms;
-}
-.tt-title {
-  font-weight: 600;
-  margin-bottom: 0.25rem;
-  font-variant-numeric: tabular-nums;
-}
-.tt-rows { display: flex; flex-direction: column; gap: 0.15rem; }
-.tt-row {
-  display: flex;
-  align-items: center;
-  gap: 0.35rem;
-  white-space: nowrap;
-}
-.tt-swatch {
-  display: inline-block;
-  width: 0.6rem;
-  height: 0.6rem;
-  border-radius: 50%;
-  flex: 0 0 auto;
-}
-.tt-label {
-  flex: 1 1 auto;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  max-width: 11rem;
-}
-.tt-value {
-  font-variant-numeric: tabular-nums;
-  font-weight: 500;
-}
-.tt-delta {
-  font-variant-numeric: tabular-nums;
-  font-size: 0.75rem;
-  opacity: 0.85;
-}
-.tt-delta--better { color: var(--good); }
-.tt-delta--worse { color: var(--bad); }
-.tt-footer {
-  margin-top: 0.4rem;
-  padding-top: 0.4rem;
-  border-top: 1px solid rgba(255, 255, 255, 0.15);
-  display: flex;
-  flex-direction: column;
-  gap: 0.2rem;
-}
-.tt-msg {
-  color: var(--tooltip-fg);
-  opacity: 0.85;
-  white-space: normal;
-  font-style: italic;
-}
-
-/* ----------------------------------------------------------------------
- * Mobile
- * ---------------------------------------------------------------------- */
-@media (max-width: 768px) {
-  :root {
-    --header-height: 56px;
-  }
-  .header-content {
-    gap: 0.5rem;
-    padding: 0 0.5rem;
-  }
-  .site-logo {
-    height: 16px;
-  }
-  .header-left {
-    gap: 0.5rem;
-  }
-  .header-center {
-    position: static;
-    flex: 0 0 auto;
-    transform: none;
-  }
-  .header-right {
-    gap: 0.35rem;
-    margin-left: auto;
-  }
-  .site-title {
-    display: none;
-  }
-  /* Mobile nav: collapse `.nav-controls` into a hamburger panel docked
-   * under the header. The hamburger toggle plants `.nav-controls--open`
-   * to surface the panel. The desktop GitHub link in `.header-right` is
-   * hidden; the panel-internal `.nav-controls-github` link takes over. */
-  .header-left .nav-mobile-toggle {
-    display: inline-flex;
-    padding: 0.4rem 0.55rem;
-    min-height: 32px;
-  }
-  .header-right .repo-link-desktop { display: none; }
-  .nav-controls .nav-controls-github { display: inline-flex; }
-  .nav-controls {
-    display: none;
-    flex-direction: column;
-    align-items: stretch;
-    gap: 0.5rem;
-    position: absolute;
-    top: var(--header-height);
-    left: 0;
-    right: 0;
-    padding: 0.75rem 1rem;
-    border-bottom: 1px solid var(--border);
-    background: var(--card-bg);
-    box-shadow: var(--shadow-md);
-    z-index: 1100;
-  }
-  .nav-controls.nav-controls--open {
-    display: flex;
-  }
-  .nav-controls .filter-dropdown { width: 100%; }
-  .nav-controls .filter-trigger { width: 100%; justify-content: center; }
-  .nav-controls .filter-panel {
-    left: 0;
-    right: 0;
-    transform: none;
-    min-width: 0;
-    max-width: none;
-  }
-  .control-btn,
-  .repo-link {
-    min-height: 32px;
-    border-radius: 6px;
-    font-size: 0.75rem;
-  }
-  .control-btn {
-    padding: 0.4rem 0.55rem;
-  }
-  .theme-toggle {
-    min-width: 3.25rem;
-  }
-  .repo-link {
-    padding: 0.4rem 0.55rem;
-  }
-  .repo-link span {
-    display: none;
-  }
-  main { padding: 1rem; }
-  .group-details {
-    margin-bottom: 1.5rem;
-    border-radius: 8px;
-  }
-  .group-summary {
-    border-radius: 8px 8px 0 0;
-  }
-  .group-summary-row {
-    flex-wrap: wrap;
-    gap: 0.5rem;
-    padding: 0.75rem 1rem;
-  }
-  .group-name {
-    flex: 1 1 auto;
-    min-width: 0;
-    font-size: 1.1rem;
-    word-break: break-word;
-  }
-  .group-count {
-    flex: 0 0 auto;
-    font-size: 0.65rem;
-  }
-  .group-details > .chart-grid {
-    padding: 0.75rem;
-  }
-  .benchmark-scores-summary {
-    padding: 0.6rem 1rem;
-  }
-  .group-toolbar {
-    padding: 0.4rem 0.75rem;
-    gap: 0.35rem 0.5rem;
-  }
-  .group-filter-panel {
-    min-width: 0;
-    width: 92vw;
-    max-width: 92vw;
-  }
-  .group-series-chips {
-    /* Wraps onto multiple lines on narrow screens; chip count stays modest
-     * (typically <10) so vertical wrap is fine. */
-    max-height: 50vh;
-    overflow-y: auto;
-  }
-  .toolbar--card {
-    gap: 0.35rem 0.6rem;
-    padding: 0.4rem 0.45rem;
-  }
-  .toolbar-btn {
-    min-height: 32px;
-    padding: 0.25rem 0.6rem;
-    font-size: 0.85rem;
-  }
-  .scores-list { column-count: 1; }
-  .score-item { align-items: flex-start; }
-  .score-metrics { flex-direction: column; gap: 0; align-items: flex-end; }
-  .toolbar-slider { width: 100%; flex: 1 1 auto; min-width: 6rem; }
-  .chart-grid { grid-template-columns: 1fr; gap: 0.5rem; }
-  .chart-wrap { height: 350px; }
-  main > .chart-card:not(.chart-grid .chart-card) .chart-wrap { height: 420px; }
-}
-
-/* ----------------------------------------------------------------------
- * Footer
- * ----------------------------------------------------------------------
- * Emitted by `html::render::site_footer` at the bottom of every page. The
- * `build <sha>` text links the short SHA to the matching commit on
- * GitHub so the rendered page is always traceable to a source revision.
- * Kept small + muted so it sits below the content without competing.
- */
-.site-footer {
-  padding: 1.5rem 2rem 2rem;
-  text-align: center;
-  color: var(--muted);
-  font-size: 0.75rem;
-  line-height: 1.4;
-}
-
-.site-footer-label {
-  color: var(--muted);
-}
-
-.site-footer-sha code {
-  font-family: "Geist Mono", ui-monospace, "SFMono-Regular", Menlo,
-    Consolas, monospace;
-  color: var(--muted);
-  font-size: 0.75rem;
-}
-
-a.site-footer-sha {
-  color: var(--muted);
-  text-decoration: none;
-  transition: color 0.2s ease;
-}
-
-a.site-footer-sha:hover,
-a.site-footer-sha:hover code {
-  color: var(--accent);
-  text-decoration: none;
-}
diff --git a/benchmarks-website/server/tests/admin.rs b/benchmarks-website/server/tests/admin.rs
deleted file mode 100644
index 108f175acff..00000000000
--- a/benchmarks-website/server/tests/admin.rs
+++ /dev/null
@@ -1,733 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Integration tests for `/api/admin/*` - round-trips the bearer check,
-//! the read-only SQL allow-list, the snapshot endpoint's path validation,
-//! and verifies that admin routes 404 when `ADMIN_BEARER_TOKEN` is unset.
-
-use std::net::SocketAddr;
-
-use anyhow::Context as _;
-use anyhow::Result;
-use serde_json::Value;
-use serde_json::json;
-use tempfile::TempDir;
-use tokio::net::TcpListener;
-use tokio::task::JoinHandle;
-use vortex_bench_server::app::AppState;
-use vortex_bench_server::app::admin_router;
-use vortex_bench_server::app::public_router;
-
-const INGEST_TOKEN: &str = "ingest-test-token";
-const ADMIN_TOKEN: &str = "admin-test-token";
-
-/// Two-listener test harness that mirrors prod: public traffic on one
-/// loopback port, admin traffic on a second loopback port. The
-/// `admin_addr` is `None` when the server was started without
-/// `with_admin`. Both listener tasks are aborted on `Drop`.
-struct Server {
-    addr: SocketAddr,
-    admin_addr: Option<SocketAddr>,
-    snapshot_dir: std::path::PathBuf,
-    state: AppState,
-    _tmp: TempDir,
-    handle: JoinHandle<()>,
-    admin_handle: Option<JoinHandle<()>>,
-}
-
-impl Server {
-    /// Start a server with the admin router enabled.
-    async fn start_with_admin() -> Result<Self> {
-        Self::start_inner(true).await
-    }
-
-    /// Start a server without the admin router (verifies admin routes 404).
-    async fn start_no_admin() -> Result<Self> {
-        Self::start_inner(false).await
-    }
-
-    async fn start_inner(enable_admin: bool) -> Result<Self> {
-        let tmp = TempDir::new()?;
-        let db_path = tmp.path().join("bench.duckdb");
-        let snapshot_dir = tmp.path().join("snapshots");
-        let mut state = AppState::open(&db_path, INGEST_TOKEN.to_string())?
-            .with_snapshot_dir(snapshot_dir.clone());
-        if enable_admin {
-            state = state.with_admin(ADMIN_TOKEN.to_string());
-        }
-
-        let public_app = public_router(state.clone());
-        let admin_app = admin_router(state.clone());
-
-        let listener = TcpListener::bind("127.0.0.1:0").await?;
-        let addr = listener.local_addr()?;
-        let handle = tokio::spawn(async move {
-            axum::serve(listener, public_app).await.unwrap();
-        });
-
-        let (admin_addr, admin_handle) = match admin_app {
-            Some(app) => {
-                let listener = TcpListener::bind("127.0.0.1:0").await?;
-                let admin_addr = listener.local_addr()?;
-                let admin_handle = tokio::spawn(async move {
-                    axum::serve(listener, app).await.unwrap();
-                });
-                (Some(admin_addr), Some(admin_handle))
-            }
-            None => (None, None),
-        };
-
-        Ok(Self {
-            addr,
-            admin_addr,
-            snapshot_dir,
-            state,
-            _tmp: tmp,
-            handle,
-            admin_handle,
-        })
-    }
-
-    /// URL for a path on the public listener.
-    fn url(&self, path: &str) -> String {
-        format!("http://{}{}", self.addr, path)
-    }
-
-    /// URL for a path on the admin listener. Panics if admin was not
-    /// enabled - tests calling this should have used `start_with_admin`.
-    fn admin_url(&self, path: &str) -> String {
-        let addr = self
-            .admin_addr
-            .expect("admin_url called on a server started without admin");
-        format!("http://{addr}{path}")
-    }
-}
-
-impl Drop for Server {
-    fn drop(&mut self) {
-        self.handle.abort();
-        if let Some(handle) = self.admin_handle.take() {
-            handle.abort();
-        }
-    }
-}
-
-#[tokio::test]
-async fn admin_sql_select_round_trips() -> Result<()> {
-    let server = Server::start_with_admin().await?;
-    let client = reqwest::Client::new();
-
-    // The schema is applied on AppState::open, so commits exists with 0 rows.
-    let resp = client
-        .post(server.admin_url("/api/admin/sql"))
-        .bearer_auth(ADMIN_TOKEN)
-        .json(&json!({ "sql": "SELECT COUNT(*) AS n FROM commits" }))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    let body: Value = resp.json().await?;
-    assert_eq!(body["columns"], json!(["n"]));
-    assert_eq!(body["rows"], json!([[0]]));
-    assert_eq!(body["row_count"], json!(1));
-    Ok(())
-}
-
-#[tokio::test]
-async fn admin_sql_table_format_renders_ascii() -> Result<()> {
-    let server = Server::start_with_admin().await?;
-    let client = reqwest::Client::new();
-
-    let resp = client
-        .post(server.admin_url("/api/admin/sql?format=table"))
-        .bearer_auth(ADMIN_TOKEN)
-        .json(&json!({ "sql": "SELECT 1 AS x, 'hello' AS y" }))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    let ct = resp
-        .headers()
-        .get(reqwest::header::CONTENT_TYPE)
-        .and_then(|h| h.to_str().ok())
-        .unwrap_or("")
-        .to_string();
-    assert!(ct.starts_with("text/plain"), "got content-type {ct:?}");
-    let body = resp.text().await?;
-    // Header check explicitly anchors on the trailing `│` to symmetrically
-    // match the data-row check, so a regression that mangled the right
-    // boundary in the header row would not silently pass. The header text
-    // `y` is padded to the widest cell value (`hello`, 5 chars), hence
-    // the spaces. `│ x │ y     │` is the literal rendered shape.
-    assert!(
-        body.contains("│ x │ y     │"),
-        "missing column header row in:\n{body}"
-    );
-    assert!(
-        body.contains("│ 1 │ hello │"),
-        "missing data row in:\n{body}"
-    );
-    assert!(body.contains("(1 row)"), "missing row count in:\n{body}");
-    Ok(())
-}
-
-#[tokio::test]
-async fn admin_sql_allows_single_trailing_semicolon() -> Result<()> {
-    let server = Server::start_with_admin().await?;
-    let client = reqwest::Client::new();
-
-    let resp = client
-        .post(server.admin_url("/api/admin/sql"))
-        .bearer_auth(ADMIN_TOKEN)
-        .json(&json!({ "sql": "SELECT 1 AS x;" }))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    let body: Value = resp.json().await?;
-    assert_eq!(body["rows"], json!([[1]]));
-    Ok(())
-}
-
-/// `validate_read_only` / `ensure_single_statement` skip leading and
-/// trailing SQL comments (both `-- line` and `/* block */`) without
-/// confusing them for additional statements. Regression test for the
-/// cycle-1 fix that added the `skip_leading_noise` helper.
-#[tokio::test]
-async fn admin_sql_accepts_leading_line_comment() -> Result<()> {
-    let server = Server::start_with_admin().await?;
-    let client = reqwest::Client::new();
-    let resp = client
-        .post(server.admin_url("/api/admin/sql"))
-        .bearer_auth(ADMIN_TOKEN)
-        .json(&json!({ "sql": "-- justify the call\nSELECT 1 AS x" }))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    let body: Value = resp.json().await?;
-    assert_eq!(body["rows"], json!([[1]]));
-    Ok(())
-}
-
-#[tokio::test]
-async fn admin_sql_accepts_leading_block_comment() -> Result<()> {
-    let server = Server::start_with_admin().await?;
-    let client = reqwest::Client::new();
-    let resp = client
-        .post(server.admin_url("/api/admin/sql"))
-        .bearer_auth(ADMIN_TOKEN)
-        .json(&json!({ "sql": "/* note */ SELECT 1 AS x" }))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    let body: Value = resp.json().await?;
-    assert_eq!(body["rows"], json!([[1]]));
-    Ok(())
-}
-
-#[tokio::test]
-async fn admin_sql_accepts_trailing_line_comment_after_semicolon() -> Result<()> {
-    let server = Server::start_with_admin().await?;
-    let client = reqwest::Client::new();
-    let resp = client
-        .post(server.admin_url("/api/admin/sql"))
-        .bearer_auth(ADMIN_TOKEN)
-        .json(&json!({ "sql": "SELECT 1 AS x; -- trailing note\n" }))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    let body: Value = resp.json().await?;
-    assert_eq!(body["rows"], json!([[1]]));
-    Ok(())
-}
-
-#[tokio::test]
-async fn admin_sql_accepts_trailing_block_comment_after_semicolon() -> Result<()> {
-    let server = Server::start_with_admin().await?;
-    let client = reqwest::Client::new();
-    let resp = client
-        .post(server.admin_url("/api/admin/sql"))
-        .bearer_auth(ADMIN_TOKEN)
-        .json(&json!({ "sql": "SELECT 1 AS x; /* trailing note */" }))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    let body: Value = resp.json().await?;
-    assert_eq!(body["rows"], json!([[1]]));
-    Ok(())
-}
-
-#[tokio::test]
-async fn admin_sql_rejects_second_statement_after_comment() -> Result<()> {
-    let server = Server::start_with_admin().await?;
-    let client = reqwest::Client::new();
-    let resp = client
-        .post(server.admin_url("/api/admin/sql"))
-        .bearer_auth(ADMIN_TOKEN)
-        .json(&json!({ "sql": "SELECT 1; /* a */ SELECT 2" }))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 403);
-    Ok(())
-}
-
-#[tokio::test]
-async fn admin_sql_allows_semicolon_inside_string_literal() -> Result<()> {
-    let server = Server::start_with_admin().await?;
-    let client = reqwest::Client::new();
-
-    let resp = client
-        .post(server.admin_url("/api/admin/sql"))
-        .bearer_auth(ADMIN_TOKEN)
-        .json(&json!({ "sql": "SELECT 'not; another statement' AS text" }))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    let body: Value = resp.json().await?;
-    assert_eq!(body["rows"], json!([["not; another statement"]]));
-    Ok(())
-}
-
-#[tokio::test]
-async fn admin_sql_rejects_multi_statement_reads() -> Result<()> {
-    let server = Server::start_with_admin().await?;
-    let client = reqwest::Client::new();
-
-    let resp = client
-        .post(server.admin_url("/api/admin/sql"))
-        .bearer_auth(ADMIN_TOKEN)
-        .json(&json!({ "sql": "SELECT 1; DROP TABLE commits; SELECT 2" }))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 403);
-    let body: Value = resp.json().await?;
-    assert_eq!(body["error"], json!("forbidden"));
-
-    let resp = client
-        .post(server.admin_url("/api/admin/sql"))
-        .bearer_auth(ADMIN_TOKEN)
-        .json(&json!({ "sql": "SELECT COUNT(*) AS n FROM commits" }))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    Ok(())
-}
-
-#[tokio::test]
-async fn admin_sql_caps_large_results() -> Result<()> {
-    let server = Server::start_with_admin().await?;
-    let client = reqwest::Client::new();
-
-    let resp = client
-        .post(server.admin_url("/api/admin/sql"))
-        .bearer_auth(ADMIN_TOKEN)
-        .json(&json!({ "sql": "SELECT * FROM range(10005)" }))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    let body: Value = resp.json().await?;
-    assert_eq!(body["row_count"], json!(10000));
-    assert_eq!(body["truncated"], json!(true));
-    Ok(())
-}
-
-#[tokio::test]
-async fn admin_sql_rejects_writes() -> Result<()> {
-    let server = Server::start_with_admin().await?;
-    let client = reqwest::Client::new();
-
-    for sql in [
-        "DELETE FROM commits",
-        "UPDATE commits SET sha = 'x'",
-        "DROP TABLE commits",
-        "INSERT INTO commits VALUES ('x')",
-        "CREATE TABLE foo (a INT)",
-        "ATTACH ':memory:' AS bar",
-    ] {
-        let resp = client
-            .post(server.admin_url("/api/admin/sql"))
-            .bearer_auth(ADMIN_TOKEN)
-            .json(&json!({ "sql": sql }))
-            .send()
-            .await?;
-        assert_eq!(resp.status(), 403, "expected 403 for {sql:?}");
-        let body: Value = resp.json().await?;
-        assert_eq!(body["error"], json!("forbidden"));
-    }
-    Ok(())
-}
-
-#[tokio::test]
-async fn admin_sql_read_only_blocks_explain_analyze_writes() -> Result<()> {
-    // `validate_read_only` allow-lists `EXPLAIN`, which means
-    // `EXPLAIN ANALYZE` slips through the SQL allow-list - DuckDB actually
-    // executes the wrapped statement. The defense in depth is the
-    // `BEGIN TRANSACTION READ ONLY` wrapper in `run_select`. Pin that
-    // behavior: if this test ever flips green by silently allowing the
-    // write, the read-only safety net is gone.
-    let server = Server::start_with_admin().await?;
-    let client = reqwest::Client::new();
-
-    let resp = client
-        .post(server.admin_url("/api/admin/sql"))
-        .bearer_auth(ADMIN_TOKEN)
-        .json(&json!({
-            "sql": "EXPLAIN ANALYZE INSERT INTO commits \
-                    (commit_sha, timestamp, tree_sha, url) \
-                    VALUES ('deadbeef', NOW(), 'tree', 'http://x')"
-        }))
-        .send()
-        .await?;
-    assert!(
-        resp.status().is_server_error(),
-        "expected DuckDB to refuse the write, got {}",
-        resp.status()
-    );
-
-    // And verify nothing landed in `commits`.
-    let resp = client
-        .post(server.admin_url("/api/admin/sql"))
-        .bearer_auth(ADMIN_TOKEN)
-        .json(&json!({ "sql": "SELECT COUNT(*) AS n FROM commits" }))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    let body: Value = resp.json().await?;
-    assert_eq!(body["rows"], json!([[0]]));
-    Ok(())
-}
-
-#[tokio::test]
-async fn admin_sql_allows_pragma_show_describe_explain_with() -> Result<()> {
-    let server = Server::start_with_admin().await?;
-    let client = reqwest::Client::new();
-
-    for sql in [
-        "PRAGMA database_size",
-        "SHOW TABLES",
-        "DESCRIBE commits",
-        "EXPLAIN SELECT 1",
-        "WITH x AS (SELECT 1 AS a) SELECT * FROM x",
-    ] {
-        let resp = client
-            .post(server.admin_url("/api/admin/sql"))
-            .bearer_auth(ADMIN_TOKEN)
-            .json(&json!({ "sql": sql }))
-            .send()
-            .await?;
-        assert_eq!(resp.status(), 200, "{sql:?} should be allowed");
-    }
-    Ok(())
-}
-
-#[tokio::test]
-async fn admin_requires_admin_bearer_not_ingest_bearer() -> Result<()> {
-    let server = Server::start_with_admin().await?;
-    let client = reqwest::Client::new();
-
-    let body = json!({ "sql": "SELECT 1" });
-
-    // No header.
-    let resp = client
-        .post(server.admin_url("/api/admin/sql"))
-        .json(&body)
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 401);
-
-    // Wrong token.
-    let resp = client
-        .post(server.admin_url("/api/admin/sql"))
-        .bearer_auth("wrong")
-        .json(&body)
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 401);
-
-    // Ingest token explicitly does NOT work on admin routes.
-    let resp = client
-        .post(server.admin_url("/api/admin/sql"))
-        .bearer_auth(INGEST_TOKEN)
-        .json(&body)
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 401);
-
-    // Right token.
-    let resp = client
-        .post(server.admin_url("/api/admin/sql"))
-        .bearer_auth(ADMIN_TOKEN)
-        .json(&body)
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    Ok(())
-}
-
-#[tokio::test]
-async fn admin_unmounted_when_admin_token_absent() -> Result<()> {
-    let server = Server::start_no_admin().await?;
-    let client = reqwest::Client::new();
-
-    // Without `with_admin` there is no admin listener at all, so the
-    // probe has to hit the public listener. The contract is "404 for any
-    // /api/admin/* path on the public listener" regardless of whether
-    // admin is configured.
-    let resp = client
-        .post(server.url("/api/admin/sql"))
-        .bearer_auth(ADMIN_TOKEN)
-        .json(&json!({ "sql": "SELECT 1" }))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 404);
-
-    let resp = client
-        .post(server.url("/api/admin/snapshot?ts=20260101T000000Z"))
-        .bearer_auth(ADMIN_TOKEN)
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 404);
-    Ok(())
-}
-
-#[tokio::test]
-async fn admin_routes_not_served_on_public_listener_when_admin_enabled() -> Result<()> {
-    // The whole point of `VORTEX_BENCH_ADMIN_BIND` is that
-    // `/api/admin/*` is unreachable on the public bind even when admin
-    // is otherwise configured. Hitting the *public* listener with the
-    // correct admin bearer must still 404.
-    let server = Server::start_with_admin().await?;
-    let client = reqwest::Client::new();
-
-    let resp = client
-        .post(server.url("/api/admin/sql"))
-        .bearer_auth(ADMIN_TOKEN)
-        .json(&json!({ "sql": "SELECT 1" }))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 404);
-
-    let resp = client
-        .post(server.url("/api/admin/snapshot?ts=20260101T000000Z"))
-        .bearer_auth(ADMIN_TOKEN)
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 404);
-
-    // Sanity: the same admin SQL call on the *admin* listener works.
-    let resp = client
-        .post(server.admin_url("/api/admin/sql"))
-        .bearer_auth(ADMIN_TOKEN)
-        .json(&json!({ "sql": "SELECT 1 AS x" }))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    Ok(())
-}
-
-// The snapshot endpoint INSTALLs and LOADs the vortex DuckDB core
-// extension on first call; that needs outbound network to
-// `extensions.duckdb.org`, which sandboxed CI environments generally
-// don't allow. Run manually before merge with the same invocation form
-// the CI workflow uses, so behaviour matches what gates the merge:
-//   cargo nextest run -p vortex-bench-server --test admin --run-ignored only
-#[tokio::test]
-#[ignore = "needs network to install the vortex DuckDB core extension"]
-async fn admin_snapshot_creates_export_directory() -> Result<()> {
-    let server = Server::start_with_admin().await?;
-    let client = reqwest::Client::new();
-
-    let ts = "20260101T000000Z";
-    let resp = client
-        .post(server.admin_url(&format!("/api/admin/snapshot?ts={ts}")))
-        .bearer_auth(ADMIN_TOKEN)
-        .send()
-        .await?;
-    let status = resp.status();
-    let text = resp.text().await?;
-    assert_eq!(status, 200, "snapshot failed: {text}");
-    let body: Value = serde_json::from_str(&text)?;
-    let dir = body["snapshot_dir"]
-        .as_str()
-        .context("snapshot_dir field")?;
-    let dir_path = std::path::PathBuf::from(dir);
-    assert!(dir_path.exists(), "{dir} should exist");
-    // schema.sql is the assembled COMMITS_DDL + per-family DDL concatenation.
-    assert!(
-        dir_path.join("schema.sql").exists(),
-        "{dir}/schema.sql should exist"
-    );
-    // One .vortex file per table - `commits` is the dim table and is
-    // present even when the DB is otherwise empty (the schema was
-    // applied at AppState::open).
-    assert!(
-        dir_path.join("commits.vortex").exists(),
-        "{dir}/commits.vortex should exist"
-    );
-    assert!(
-        dir_path.join("query_measurements.vortex").exists(),
-        "{dir}/query_measurements.vortex should exist"
-    );
-    // And the directory should be under the configured snapshot dir.
-    assert!(
-        dir_path.starts_with(&server.snapshot_dir),
-        "{dir} not under {:?}",
-        server.snapshot_dir
-    );
-    Ok(())
-}
-
-#[tokio::test]
-#[ignore = "needs network to install the vortex DuckDB core extension"]
-async fn admin_snapshot_rejects_existing_directory() -> Result<()> {
-    let server = Server::start_with_admin().await?;
-    let client = reqwest::Client::new();
-
-    let ts = "20260102T000000Z";
-    let resp = client
-        .post(server.admin_url(&format!("/api/admin/snapshot?ts={ts}")))
-        .bearer_auth(ADMIN_TOKEN)
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-
-    // Second call with same ts → 409.
-    let resp = client
-        .post(server.admin_url(&format!("/api/admin/snapshot?ts={ts}")))
-        .bearer_auth(ADMIN_TOKEN)
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 409);
-    Ok(())
-}
-
-#[tokio::test]
-#[ignore = "needs network to install the vortex DuckDB core extension"]
-async fn admin_snapshot_concurrent_same_ts_yields_one_200_and_one_409() -> Result<()> {
-    let server = Server::start_with_admin().await?;
-    let ts = "20260103T000000Z";
-
-    let client_a = reqwest::Client::new();
-    let client_b = reqwest::Client::new();
-    let url = server.admin_url(&format!("/api/admin/snapshot?ts={ts}"));
-    let url_a = url.clone();
-    let url_b = url;
-
-    let a =
-        tokio::spawn(async move { client_a.post(&url_a).bearer_auth(ADMIN_TOKEN).send().await });
-    let b =
-        tokio::spawn(async move { client_b.post(&url_b).bearer_auth(ADMIN_TOKEN).send().await });
-
-    let resp_a = a.await??;
-    let resp_b = b.await??;
-    let mut codes = [resp_a.status().as_u16(), resp_b.status().as_u16()];
-    codes.sort();
-    assert_eq!(
-        codes,
-        [200, 409],
-        "expected exactly one 200 and one 409 for concurrent snapshots with same ts"
-    );
-    Ok(())
-}
-
-#[tokio::test]
-#[ignore = "needs network to install the vortex DuckDB core extension"]
-async fn admin_snapshot_captures_committed_row_under_read_only_transaction() -> Result<()> {
-    // The per-table COPYs run inside a single `BEGIN TRANSACTION READ ONLY`.
-    // The contract is that a row already committed to `commits` lands in
-    // the snapshot's `commits.vortex`. A full "ingest mid-snapshot" race
-    // is hard to make deterministic, so this test pins the easier half:
-    // commit-then-snapshot must see the commit.
-    let server = Server::start_with_admin().await?;
-    let client = reqwest::Client::new();
-    let sha = "deadbeefcafebabedeadbeefcafebabedeadbeef";
-    {
-        let sha = sha.to_string();
-        vortex_bench_server::db::run_blocking(&server.state.db, move |conn| {
-            conn.execute_batch(&format!(
-                "INSERT INTO commits (commit_sha, timestamp, tree_sha, url) \
-                 VALUES ('{sha}', NOW(), 'tree-sha', 'http://example/{sha}')"
-            ))?;
-            Ok(())
-        })
-        .await?;
-    }
-
-    let ts = "20260104T000000Z";
-    let resp = client
-        .post(server.admin_url(&format!("/api/admin/snapshot?ts={ts}")))
-        .bearer_auth(ADMIN_TOKEN)
-        .send()
-        .await?;
-    let status = resp.status();
-    let text = resp.text().await?;
-    assert_eq!(status, 200, "snapshot failed: {text}");
-    let body: Value = serde_json::from_str(&text)?;
-    let snapshot_dir = body["snapshot_dir"]
-        .as_str()
-        .context("snapshot_dir field")?
-        .to_string();
-    let commits_path = format!("{snapshot_dir}/commits.vortex");
-
-    // Round-trip through the read-only `/api/admin/sql` endpoint so the
-    // verification uses the same DuckDB + Vortex extension the server
-    // produced the snapshot with - no separate process or path to keep
-    // in sync.
-    let resp = client
-        .post(server.admin_url("/api/admin/sql"))
-        .bearer_auth(ADMIN_TOKEN)
-        .json(&json!({
-            "sql": format!(
-                "SELECT commit_sha FROM read_vortex('{commits_path}')"
-            )
-        }))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    let body: Value = resp.json().await?;
-    assert_eq!(
-        body["rows"],
-        json!([[sha]]),
-        "snapshot's commits.vortex did not contain the committed row"
-    );
-    Ok(())
-}
-
-#[tokio::test]
-async fn admin_snapshot_validates_ts() -> Result<()> {
-    let server = Server::start_with_admin().await?;
-    let client = reqwest::Client::new();
-
-    let too_long = "x".repeat(65);
-    for bad_ts in [
-        "",
-        "../oops",
-        "with space",
-        too_long.as_str(),
-        // ISO-8601-looking inputs that operators might paste but the
-        // regex `[A-Za-z0-9_-]+` does not accept (`.` for fractional
-        // seconds, `:` for time, `+` for offset). Pin the rejection so a
-        // future regex relaxation does not silently let through path
-        // characters that break the snapshot dir layout.
-        "2026-01-01T00:00:00Z",
-        "2026-01-01+00:00",
-        "20260101.000000Z",
-    ] {
-        let url = server.admin_url(&format!("/api/admin/snapshot?ts={}", urlencoding(bad_ts)));
-        let resp = client.post(&url).bearer_auth(ADMIN_TOKEN).send().await?;
-        assert_eq!(resp.status(), 400, "expected 400 for ts={bad_ts:?}");
-    }
-    Ok(())
-}
-
-/// Tiny URL-encoder so the test doesn't grow another dep. Only handles the
-/// characters our bad-ts cases produce.
-fn urlencoding(s: &str) -> String {
-    let mut out = String::with_capacity(s.len());
-    for b in s.bytes() {
-        match b {
-            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
-                out.push(b as char);
-            }
-            _ => out.push_str(&format!("%{b:02X}")),
-        }
-    }
-    out
-}
diff --git a/benchmarks-website/server/tests/chart_api.rs b/benchmarks-website/server/tests/chart_api.rs
deleted file mode 100644
index 216da62bd0c..00000000000
--- a/benchmarks-website/server/tests/chart_api.rs
+++ /dev/null
@@ -1,395 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Integration tests for `/chart/{slug}` and `/api/chart/{slug}`.
-
-mod common;
-
-use anyhow::Context as _;
-use anyhow::Result;
-use serde_json::Value;
-
-use self::common::Server;
-use self::common::insta_settings;
-use self::common::pick_chart_slug;
-use self::common::seed;
-use self::common::seed_long_history;
-
-#[tokio::test]
-async fn chart_page_snapshot() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let client = reqwest::Client::new();
-    // The query_measurements chart has two series so the snapshot
-    // exercises multi-series rendering.
-    let slug = pick_chart_slug(&server, |s| s.starts_with("TPC-H")).await?;
-
-    let resp = client
-        .get(server.url(&format!("/chart/{slug}")))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    let body = resp.text().await?;
-    assert!(
-        body.contains(r#"<script id="chart-data-0" type="application/json">"#),
-        "chart payload must be embedded inline"
-    );
-    assert!(
-        body.contains(r#"<script src="/static/chart.umd.js"#),
-        "Chart.js must be referenced from the static asset route"
-    );
-    assert!(
-        body.contains(r#"<script src="/static/chartjs-plugin-zoom.umd.min.js"#),
-        "zoom plugin must be loaded for /chart pages"
-    );
-    assert!(
-        body.contains(r#"class="toolbar toolbar--card""#),
-        "per-chart toolbar must be rendered on chart page"
-    );
-
-    insta_settings().bind(|| {
-        insta::assert_snapshot!("chart_page_query", body);
-    });
-    Ok(())
-}
-
-/// `GET /api/chart/{slug}` returns the JSON shape the chart-init.js fetches
-/// on lazy-load (closed-by-default `<details>` groups).
-#[tokio::test]
-async fn chart_api_returns_payload_shape() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let slug = pick_chart_slug(&server, |s| s.starts_with("TPC-H")).await?;
-
-    let client = reqwest::Client::new();
-    let resp = client
-        .get(server.url(&format!("/api/chart/{slug}")))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    let ct = resp
-        .headers()
-        .get(reqwest::header::CONTENT_TYPE)
-        .and_then(|v| v.to_str().ok())
-        .unwrap_or("")
-        .to_string();
-    assert!(
-        ct.starts_with("application/json"),
-        "expected JSON content-type, got {ct:?}"
-    );
-    let body: Value = resp.json().await?;
-    assert!(body["display_name"].as_str().is_some(), "display_name");
-    assert_eq!(
-        body["unit_kind"].as_str(),
-        Some("time_ns"),
-        "TPC-H query timing chart must declare its base unit as time_ns"
-    );
-    assert!(body["commits"].as_array().is_some(), "commits");
-    assert!(body["series"].as_object().is_some(), "series");
-
-    // ?n= narrows the commit count.
-    let one: Value = client
-        .get(server.url(&format!("/api/chart/{slug}?n=1")))
-        .send()
-        .await?
-        .json()
-        .await?;
-    let one_count = one["commits"].as_array().map(|a| a.len()).unwrap_or(0);
-    assert_eq!(one_count, 1, "?n=1 should keep exactly one commit");
-
-    // A valid-shape slug for a chart that doesn't exist in the DB returns
-    // 404. (Malformed slugs are 400, covered by the HTML route tests.)
-    let unknown_slug = vortex_bench_server::slug::ChartKey::QueryMeasurement {
-        dataset: "missing-dataset".into(),
-        dataset_variant: None,
-        scale_factor: None,
-        storage: "nvme".into(),
-        query_idx: 99,
-    }
-    .to_slug();
-    let missing = client
-        .get(server.url(&format!("/api/chart/{unknown_slug}")))
-        .send()
-        .await?;
-    assert_eq!(missing.status(), 404);
-    Ok(())
-}
-
-#[tokio::test]
-async fn default_chart_api_serves_materialized_encoded_artifact() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let slug = pick_chart_slug(&server, |s| s.starts_with("TPC-H")).await?;
-
-    let client = reqwest::Client::new();
-    let resp = client
-        .get(server.url(&format!("/api/chart/{slug}")))
-        .header(reqwest::header::ACCEPT_ENCODING, "gzip")
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    assert_eq!(
-        resp.headers()
-            .get(reqwest::header::CONTENT_ENCODING)
-            .and_then(|v| v.to_str().ok()),
-        Some("gzip"),
-        "default latest-100 chart endpoint should serve precompressed gzip"
-    );
-    assert!(
-        resp.headers()
-            .get(reqwest::header::VARY)
-            .and_then(|v| v.to_str().ok())
-            .is_some_and(|v| v.eq_ignore_ascii_case("Accept-Encoding")),
-        "materialized artifact should vary on Accept-Encoding"
-    );
-    let etag = resp
-        .headers()
-        .get(reqwest::header::ETAG)
-        .cloned()
-        .context("materialized chart ETag")?;
-    assert!(
-        resp.headers()
-            .get(reqwest::header::CONTENT_LENGTH)
-            .is_some(),
-        "materialized artifact should carry Content-Length"
-    );
-
-    let not_modified = client
-        .get(server.url(&format!("/api/chart/{slug}")))
-        .header(reqwest::header::IF_NONE_MATCH, etag)
-        .send()
-        .await?;
-    assert_eq!(not_modified.status(), 304);
-    Ok(())
-}
-
-#[tokio::test]
-async fn chart_api_reports_virtual_history_for_bounded_and_full_windows() -> Result<()> {
-    let server = Server::start().await?;
-    seed_long_history(&server, 125).await?;
-
-    let slug = pick_chart_slug(&server, |s| s == "Random Access").await?;
-    let client = reqwest::Client::new();
-
-    let bounded: Value = client
-        .get(server.url(&format!("/api/chart/{slug}")))
-        .send()
-        .await?
-        .json()
-        .await?;
-    assert_eq!(
-        bounded["commits"].as_array().map(Vec::len),
-        Some(100),
-        "default materialized chart payload should stay latest-100"
-    );
-    assert_eq!(bounded["history"]["total_commits"].as_u64(), Some(125));
-    assert_eq!(bounded["history"]["start_index"].as_u64(), Some(25));
-    assert_eq!(bounded["history"]["loaded_commits"].as_u64(), Some(100));
-    assert_eq!(bounded["history"]["complete"].as_bool(), Some(false));
-
-    let all: Value = client
-        .get(server.url(&format!("/api/chart/{slug}?n=all")))
-        .send()
-        .await?
-        .json()
-        .await?;
-    assert_eq!(all["commits"].as_array().map(Vec::len), Some(125));
-    assert_eq!(all["history"]["total_commits"].as_u64(), Some(125));
-    assert_eq!(all["history"]["start_index"].as_u64(), Some(0));
-    assert_eq!(all["history"]["loaded_commits"].as_u64(), Some(125));
-    assert_eq!(all["history"]["complete"].as_bool(), Some(true));
-    Ok(())
-}
-
-#[tokio::test]
-async fn chart_page_window_caps_commits() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let slug = pick_chart_slug(&server, |s| s.starts_with("TPC-H")).await?;
-
-    let client = reqwest::Client::new();
-    // Without `?n`, the API default is `Last(DEFAULT_COMMIT_WINDOW)`. The
-    // fixture has 3 commits which fits comfortably.
-    let full: Value = client
-        .get(server.url(&format!("/api/chart/{slug}")))
-        .send()
-        .await?
-        .json()
-        .await?;
-    let full_count = full["commits"].as_array().map(|a| a.len()).unwrap_or(0);
-    assert!(full_count >= 3, "expected ≥ 3 commits, got {full_count}");
-
-    // ?n=1 should cap to one commit.
-    let one: Value = client
-        .get(server.url(&format!("/api/chart/{slug}?n=1")))
-        .send()
-        .await?
-        .json()
-        .await?;
-    let one_count = one["commits"].as_array().map(|a| a.len()).unwrap_or(0);
-    assert_eq!(one_count, 1, "?n=1 should keep exactly one commit");
-
-    // ?n=all remains the explicit full-history view.
-    let all: Value = client
-        .get(server.url(&format!("/api/chart/{slug}?n=all")))
-        .send()
-        .await?
-        .json()
-        .await?;
-    let all_count = all["commits"].as_array().map(|a| a.len()).unwrap_or(0);
-    assert_eq!(all_count, full_count, "?n=all should match unbounded view");
-
-    // Very large numeric `?n` values are clamped to MAX_NUMERIC_COMMIT_WINDOW
-    // at parse time (see the `commit_window_parse_floors_zero_and_clamps_large_values`
-    // unit test in `api/window.rs`, which is the strong contract). This
-    // integration test sanity-checks the round-trip on a small fixture: the
-    // clamp is well above the fixture's 3 commits, so the visible count
-    // matches the default response. The contract is "clamp is applied;
-    // huge_count is <= MAX_NUMERIC_COMMIT_WINDOW AND equals
-    // min(MAX_NUMERIC_COMMIT_WINDOW, full_count)" rather than the prior
-    // tautological `huge_count == full_count`.
-    let huge: Value = client
-        .get(server.url(&format!("/api/chart/{slug}?n=99999")))
-        .send()
-        .await?
-        .json()
-        .await?;
-    let huge_count = huge["commits"].as_array().map(|a| a.len()).unwrap_or(0);
-    assert!(
-        huge_count <= 1_000,
-        "?n=99999 should be clamped to <= MAX_NUMERIC_COMMIT_WINDOW (1000), got {huge_count}"
-    );
-    assert_eq!(
-        huge_count,
-        full_count.min(1_000),
-        "?n=99999 should equal min(MAX_NUMERIC_COMMIT_WINDOW, fixture)"
-    );
-
-    // Malformed ?n gracefully falls back to default.
-    let bad = client
-        .get(server.url(&format!("/api/chart/{slug}?n=banana")))
-        .send()
-        .await?;
-    assert_eq!(bad.status(), 200);
-    Ok(())
-}
-
-/// Chart payload exposes per-series engine/format tags so the global filter
-/// has the metadata it needs to drive bulk hide/show.
-#[tokio::test]
-async fn chart_payload_includes_series_meta() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let slug = pick_chart_slug(&server, |s| s.starts_with("TPC-H")).await?;
-    let client = reqwest::Client::new();
-    let body: Value = client
-        .get(server.url(&format!("/api/chart/{slug}")))
-        .send()
-        .await?
-        .json()
-        .await?;
-
-    let meta = body["series_meta"]
-        .as_object()
-        .context("series_meta must be present for query measurements")?;
-    let row = meta
-        .get("datafusion:vortex-file-compressed")
-        .context("expected series tag")?;
-    assert_eq!(row["engine"].as_str(), Some("datafusion"));
-    assert_eq!(row["format"].as_str(), Some("vortex-file-compressed"));
-
-    // Compression-time series carry a format tag but no engine.
-    let comp_slug = pick_chart_slug(&server, |s| s == "Compression").await?;
-    let comp_body: Value = client
-        .get(server.url(&format!("/api/chart/{comp_slug}")))
-        .send()
-        .await?
-        .json()
-        .await?;
-    let comp_meta = comp_body["series_meta"]
-        .as_object()
-        .context("series_meta must be present for compression times")?;
-    let row = comp_meta
-        .get("vortex-file-compressed:encode")
-        .context("expected encode series tag")?;
-    assert!(row["engine"].is_null() || row.get("engine").is_none());
-    assert_eq!(row["format"].as_str(), Some("vortex-file-compressed"));
-    Ok(())
-}
-
-/// Every chart payload must declare a structured `unit_kind` so the client
-/// can pick a display unit without guessing from the values. The taxonomy
-/// lives on [`vortex_bench_server::api::UnitKind`]; this test pins the wire
-/// classification of every fact-table family currently emitted.
-#[tokio::test]
-async fn chart_payload_declares_unit_kind_per_family() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-    let client = reqwest::Client::new();
-
-    // Each (group-name needle, expected unit_kind) pair pins the
-    // classification for one fact-table family. If the underlying base unit
-    // ever changes, this test fails loudly and the unit picker in
-    // `chart-init.js` must be updated to match. Group names are matched as
-    // `name == needle || name.starts_with(needle)` so `"TPC-H"` covers every
-    // SF/storage variant and `"Compression"` exact-matches the sole
-    // compression-time group.
-    let cases = [
-        ("query_measurement", "TPC-H", "time_ns"),
-        ("compression_time", "Compression", "time_ns"),
-        ("compression_size", "Compression Size", "bytes"),
-        ("random_access_time", "Random Access", "time_ns"),
-    ];
-    for (label, needle, expected) in cases {
-        let slug =
-            pick_chart_slug(&server, |name| name == needle || name.starts_with(needle)).await?;
-        let body: Value = client
-            .get(server.url(&format!("/api/chart/{slug}")))
-            .send()
-            .await?
-            .json()
-            .await?;
-        assert_eq!(
-            body["unit_kind"].as_str(),
-            Some(expected),
-            "{label} chart must report unit_kind={expected}, got {:?}",
-            body["unit_kind"],
-        );
-        // The legacy free-form `unit` string was removed; only `unit_kind`
-        // travels on the wire now.
-        assert!(
-            body.get("unit").is_none(),
-            "{label} chart wire payload must not carry the legacy `unit` field, got {:?}",
-            body.get("unit"),
-        );
-    }
-    Ok(())
-}
-
-/// The wire payload no longer carries a `raw_commit_count` field — visual
-/// downsampling moved to the client, so the server has no opinion on
-/// rendered point count.
-#[tokio::test]
-async fn chart_payload_does_not_carry_raw_commit_count() -> Result<()> {
-    let server = Server::start().await?;
-    seed_long_history(&server, 50).await?;
-
-    let slug = pick_chart_slug(&server, |s| s == "Random Access").await?;
-    let client = reqwest::Client::new();
-    let body: Value = client
-        .get(server.url(&format!("/api/chart/{slug}")))
-        .send()
-        .await?
-        .json()
-        .await?;
-    assert!(
-        body.get("raw_commit_count").is_none(),
-        "raw_commit_count should not appear on the wire; got {body:?}"
-    );
-    Ok(())
-}
diff --git a/benchmarks-website/server/tests/common/mod.rs b/benchmarks-website/server/tests/common/mod.rs
deleted file mode 100644
index 43f55e5c59c..00000000000
--- a/benchmarks-website/server/tests/common/mod.rs
+++ /dev/null
@@ -1,581 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Shared fixtures for the integration tests.
-//!
-//! Each test file in `server/tests/` is its own crate; this module is
-//! `mod common;`'d into each so they share the [`Server`] harness, the
-//! seed envelopes, and the response-extraction helpers without duplicating
-//! the in-process startup boilerplate.
-
-#![allow(dead_code)]
-
-use std::net::SocketAddr;
-
-use anyhow::Context as _;
-use anyhow::Result;
-use serde_json::Value;
-use serde_json::json;
-use tempfile::TempDir;
-use tokio::net::TcpListener;
-use tokio::task::JoinHandle;
-use tokio::time::Duration;
-use vortex_bench_server::app::AppState;
-use vortex_bench_server::app::router;
-
-/// Bearer token wired into the in-process server. Test ingest calls send
-/// this in `Authorization: Bearer …`.
-pub(crate) const TOKEN: &str = "test-bearer-token";
-
-/// In-process axum server bound to a random port. Drops cleanly on `Drop`.
-pub(crate) struct Server {
-    /// Loopback address the server is listening on.
-    pub(crate) addr: SocketAddr,
-    _tmp: TempDir,
-    handle: JoinHandle<()>,
-}
-
-impl Server {
-    /// Spin up an in-process server backed by a fresh temp DuckDB.
-    pub(crate) async fn start() -> Result<Self> {
-        let tmp = TempDir::new()?;
-        let db_path = tmp.path().join("bench.duckdb");
-        let state = AppState::open(&db_path, TOKEN.to_string())?;
-        let app = router(state);
-
-        let listener = TcpListener::bind("127.0.0.1:0").await?;
-        let addr = listener.local_addr()?;
-        let handle = tokio::spawn(async move {
-            axum::serve(listener, app).await.unwrap();
-        });
-        Ok(Self {
-            addr,
-            _tmp: tmp,
-            handle,
-        })
-    }
-
-    /// Build an absolute URL for `path` against the in-process server.
-    pub(crate) fn url(&self, path: &str) -> String {
-        format!("http://{}{}", self.addr, path)
-    }
-}
-
-impl Drop for Server {
-    fn drop(&mut self) {
-        self.handle.abort();
-    }
-}
-
-/// Three synthetic commits, oldest first. Picked so the rendered output has
-/// short SHAs that are visually distinct in snapshots.
-pub(crate) fn commits() -> &'static [(&'static str, &'static str, &'static str)] {
-    &[
-        (
-            "1111111111111111111111111111111111111111",
-            "2026-04-23T12:00:00Z",
-            "first commit",
-        ),
-        (
-            "2222222222222222222222222222222222222222",
-            "2026-04-24T12:00:00Z",
-            "second commit",
-        ),
-        (
-            "3333333333333333333333333333333333333333",
-            "2026-04-25T12:00:00Z",
-            "third commit",
-        ),
-    ]
-}
-
-/// Build a fixture envelope for one commit; `value_bias` is added to each
-/// numeric measurement so successive commits produce a non-flat time series.
-pub(crate) fn envelope_for(sha: &str, ts: &str, msg: &str, value_bias: i64) -> Value {
-    json!({
-        "run_meta": {
-            "benchmark_id": "web-ui-fixture",
-            "schema_version": 1,
-            "started_at": ts
-        },
-        "commit": {
-            "sha": sha,
-            "timestamp": ts,
-            "message": msg,
-            "author_name": "Test Author",
-            "author_email": "author@example.com",
-            "committer_name": "Test Committer",
-            "committer_email": "committer@example.com",
-            "tree_sha": "fedcba9876543210fedcba9876543210fedcba98",
-            "url": format!("https://github.com/vortex-data/vortex/commit/{sha}")
-        },
-        "records": [
-            {
-                "kind": "query_measurement",
-                "commit_sha": sha,
-                "dataset": "tpch",
-                "scale_factor": "1",
-                "query_idx": 1,
-                "storage": "nvme",
-                "engine": "datafusion",
-                "format": "vortex-file-compressed",
-                "value_ns": 1_000_000 + value_bias,
-                "all_runtimes_ns": [1_000_000 + value_bias]
-            },
-            {
-                "kind": "query_measurement",
-                "commit_sha": sha,
-                "dataset": "tpch",
-                "scale_factor": "1",
-                "query_idx": 1,
-                "storage": "nvme",
-                "engine": "duckdb",
-                "format": "parquet",
-                "value_ns": 800_000 + value_bias,
-                "all_runtimes_ns": [800_000 + value_bias]
-            },
-            {
-                "kind": "query_measurement",
-                "commit_sha": sha,
-                "dataset": "tpch",
-                "scale_factor": "1",
-                "query_idx": 2,
-                "storage": "nvme",
-                "engine": "datafusion",
-                "format": "vortex-file-compressed",
-                "value_ns": 600_000 + value_bias,
-                "all_runtimes_ns": [600_000 + value_bias]
-            },
-            {
-                "kind": "compression_time",
-                "commit_sha": sha,
-                "dataset": "tpch-lineitem",
-                "format": "vortex-file-compressed",
-                "op": "encode",
-                "value_ns": 9_000 + value_bias,
-                "all_runtimes_ns": [9_000 + value_bias]
-            },
-            {
-                "kind": "compression_time",
-                "commit_sha": sha,
-                "dataset": "tpch-lineitem",
-                "format": "vortex-file-compressed",
-                "op": "decode",
-                "value_ns": 5_000 + value_bias,
-                "all_runtimes_ns": [5_000 + value_bias]
-            },
-            {
-                "kind": "compression_time",
-                "commit_sha": sha,
-                "dataset": "tpch-lineitem",
-                "format": "parquet",
-                "op": "encode",
-                "value_ns": 18_000 + (2 * value_bias),
-                "all_runtimes_ns": [18_000 + (2 * value_bias)]
-            },
-            {
-                "kind": "compression_time",
-                "commit_sha": sha,
-                "dataset": "tpch-lineitem",
-                "format": "parquet",
-                "op": "decode",
-                "value_ns": 10_000 + (2 * value_bias),
-                "all_runtimes_ns": [10_000 + (2 * value_bias)]
-            },
-            {
-                "kind": "compression_size",
-                "commit_sha": sha,
-                "dataset": "tpch-lineitem",
-                "format": "vortex-file-compressed",
-                "value_bytes": 4_000 + value_bias
-            },
-            {
-                "kind": "compression_size",
-                "commit_sha": sha,
-                "dataset": "tpch-lineitem",
-                "format": "parquet",
-                "value_bytes": 8_000 + (2 * value_bias)
-            },
-            {
-                "kind": "random_access_time",
-                "commit_sha": sha,
-                "dataset": "taxi",
-                "format": "vortex-file-compressed",
-                "value_ns": 500 + value_bias,
-                "all_runtimes_ns": [500 + value_bias]
-            },
-            {
-                "kind": "random_access_time",
-                "commit_sha": sha,
-                "dataset": "taxi",
-                "format": "parquet",
-                "value_ns": 1_000 + (2 * value_bias),
-                "all_runtimes_ns": [1_000 + (2 * value_bias)]
-            },
-            {
-                "kind": "vector_search_run",
-                "commit_sha": sha,
-                "dataset": "cohere-large-10m",
-                "layout": "partitioned",
-                "flavor": "vortex-turboquant",
-                "threshold": 0.75,
-                "value_ns": 7_000 + value_bias,
-                "all_runtimes_ns": [7_000 + value_bias],
-                "matches": 42,
-                "rows_scanned": 1_000_000,
-                "bytes_scanned": 5_000_000,
-                "iterations": 1
-            }
-        ]
-    })
-}
-
-/// POST every fixture commit through `/api/ingest` so the test DB is
-/// pre-populated before the test exercises the read API.
-pub(crate) async fn seed(server: &Server) -> Result<()> {
-    let client = reqwest::Client::new();
-    for (i, (sha, ts, msg)) in commits().iter().enumerate() {
-        let bias = (i as i64) * 50_000;
-        let resp = client
-            .post(server.url("/api/ingest"))
-            .bearer_auth(TOKEN)
-            .json(&envelope_for(sha, ts, msg, bias))
-            .send()
-            .await?;
-        anyhow::ensure!(
-            resp.status().is_success(),
-            "seed ingest #{i} failed: {}",
-            resp.status()
-        );
-    }
-    wait_for_materialized_first_chart_commits(server, commits().len()).await?;
-    Ok(())
-}
-
-/// Slim ingest envelope carrying just a `random_access_time` pair so we can
-/// drive a long-history fixture cheaply (the full envelope is ~12 records;
-/// this is two). Used by the downsample tests.
-pub(crate) fn ra_envelope_for(sha: &str, ts: &str, msg: &str, bias: i64) -> Value {
-    json!({
-        "run_meta": {
-            "benchmark_id": "downsample-fixture",
-            "schema_version": 1,
-            "started_at": ts
-        },
-        "commit": {
-            "sha": sha,
-            "timestamp": ts,
-            "message": msg,
-            "author_name": "Test Author",
-            "author_email": "author@example.com",
-            "committer_name": "Test Committer",
-            "committer_email": "committer@example.com",
-            "tree_sha": "fedcba9876543210fedcba9876543210fedcba98",
-            "url": format!("https://github.com/vortex-data/vortex/commit/{sha}")
-        },
-        "records": [
-            {
-                "kind": "random_access_time",
-                "commit_sha": sha,
-                "dataset": "taxi",
-                "format": "vortex-file-compressed",
-                "value_ns": 500 + bias,
-                "all_runtimes_ns": [500 + bias]
-            },
-            {
-                "kind": "random_access_time",
-                "commit_sha": sha,
-                "dataset": "taxi",
-                "format": "parquet",
-                "value_ns": 1_000 + (2 * bias),
-                "all_runtimes_ns": [1_000 + (2 * bias)]
-            }
-        ]
-    })
-}
-
-/// Seed a `Random Access` chart with `n` synthetic commits so the
-/// downsampler has something to chew on. SHAs are deterministic
-/// `{i:040x}`; timestamps are 1 minute apart starting 2025-01-01 so the
-/// commits sort stably.
-pub(crate) async fn seed_long_history(server: &Server, n: usize) -> Result<()> {
-    let client = reqwest::Client::new();
-    for i in 0..n {
-        let sha = format!("{i:040x}");
-        let minutes = i;
-        let ts = format!(
-            "2025-01-01T{:02}:{:02}:00Z",
-            (minutes / 60) % 24,
-            minutes % 60
-        );
-        // Sinusoidal bias so the series has interior peaks LTTB will retain.
-        let bias = ((i as f64).sin() * 1_000.0) as i64 + i as i64 * 10;
-        let resp = client
-            .post(server.url("/api/ingest"))
-            .bearer_auth(TOKEN)
-            .json(&ra_envelope_for(&sha, &ts, "synthetic", bias))
-            .send()
-            .await?;
-        anyhow::ensure!(
-            resp.status().is_success(),
-            "long-history ingest #{i} failed: {}",
-            resp.status()
-        );
-    }
-    wait_for_materialized_first_chart_commits(server, n).await?;
-    Ok(())
-}
-
-/// Wait until the background read-model rebuild has made the first group's
-/// first shard visible with at least `min_commits` commits on its first chart.
-pub(crate) async fn wait_for_materialized_first_chart_commits(
-    server: &Server,
-    min_commits: usize,
-) -> Result<()> {
-    wait_for_materialized_group_chart_commits(server, "Random Access", min_commits).await
-}
-
-/// Wait until a named group is visible in the active read generation and its
-/// first shard's first chart has at least `min_commits` commits.
-pub(crate) async fn wait_for_materialized_group_chart_commits(
-    server: &Server,
-    group_name: &str,
-    min_commits: usize,
-) -> Result<()> {
-    let client = reqwest::Client::new();
-    let mut last_count = 0usize;
-    for _ in 0..100 {
-        let landing = client.get(server.url("/")).send().await?.text().await?;
-        let Some(generation) = attr_value(&landing, "data-artifact-generation") else {
-            tokio::time::sleep(Duration::from_millis(25)).await;
-            continue;
-        };
-        let groups: Value = client
-            .get(server.url("/api/groups"))
-            .send()
-            .await?
-            .json()
-            .await?;
-        let Some(group_slug) = groups["groups"]
-            .as_array()
-            .and_then(|groups| {
-                groups
-                    .iter()
-                    .find(|group| group["name"].as_str() == Some(group_name))
-            })
-            .and_then(|group| group["slug"].as_str())
-            .map(str::to_string)
-        else {
-            tokio::time::sleep(Duration::from_millis(25)).await;
-            continue;
-        };
-        let resp = client
-            .get(server.url(&format!(
-                "/api/artifacts/{generation}/groups/{group_slug}/shards/0"
-            )))
-            .send()
-            .await?;
-        if resp.status().is_success() {
-            let body: Value = resp.json().await?;
-            let chart = &body["charts"][0];
-            last_count = chart["history"]["total_commits"]
-                .as_u64()
-                .and_then(|n| usize::try_from(n).ok())
-                .or_else(|| chart["commits"].as_array().map(Vec::len))
-                .unwrap_or_default();
-            if last_count >= min_commits {
-                return Ok(());
-            }
-        }
-        tokio::time::sleep(Duration::from_millis(25)).await;
-    }
-    anyhow::bail!(
-        "read model did not reach {min_commits} commits on {group_name:?}; last count {last_count}"
-    )
-}
-
-/// Pull the inline `<script id="chart-data-N">…</script>` JSON out of an
-/// HTML body. Returns `None` if the script tag isn't present.
-pub(crate) fn extract_chart_data(body: &str, idx: usize) -> Option<Value> {
-    let needle = format!(r#"<script id="chart-data-{idx}" type="application/json">"#);
-    let start = body.find(&needle)? + needle.len();
-    let end = body[start..].find("</script>")? + start;
-    // Reverse the `</` neutralisation done by `escape_json_for_script`.
-    let json = body[start..end].replace(r"<\/", "</");
-    serde_json::from_str(&json).ok()
-}
-
-/// Pull a simple double-quoted HTML attribute value from `body`.
-pub(crate) fn attr_value(body: &str, attr: &str) -> Option<String> {
-    let needle = format!(r#"{attr}=""#);
-    let start = body.find(&needle)? + needle.len();
-    let end = body[start..].find('"')? + start;
-    Some(body[start..end].to_string())
-}
-
-/// Configure `insta` to look for snapshots in `tests/snapshots/` keyed by
-/// just the explicit name (no module prefix). Every test in this crate uses
-/// these settings so the snapshot file layout is path-independent.
-pub(crate) fn insta_settings() -> insta::Settings {
-    let mut s = insta::Settings::clone_current();
-    s.set_snapshot_path("snapshots");
-    s.set_prepend_module_to_snapshot(false);
-    // Redact the build SHA in the footer so the locked snapshots survive
-    // every commit. The footer in `html::render::site_footer` embeds the
-    // real `git rev-parse HEAD` of the build (captured by `build.rs` into
-    // `VORTEX_BENCH_BUILD_SHA`); without redaction the three HTML
-    // snapshots would diff on every PR. The regex is anchored on the
-    // footer's `class="site-footer-sha"` attribute so it does NOT also
-    // match `<a href="https://github.com/vortex-data/vortex/commit/...">`
-    // URLs that come from ingested COMMITS rows (the fixtures use
-    // 1111..., 2222..., 3333... so a regression that misrenders those
-    // links is still pinned). The hex match is `{7,40}` so an extended
-    // disambiguating short-SHA (git auto-extends to 8-12 chars when the
-    // 7-char prefix is ambiguous) is also caught.
-    s.add_filter(
-        concat!(
-            r#"class="site-footer-sha"[^>]*href="https://github\.com/vortex-data/vortex/commit/"#,
-            r#"[0-9a-f]{7,40}"[^>]*><code>[0-9a-f]{7,40}</code></a>"#,
-        ),
-        r#"class="site-footer-sha" href="https://github.com/vortex-data/vortex/commit/<build-sha>" rel="noopener noreferrer" target="_blank"><code><build-sha></code></a>"#,
-    );
-    s
-}
-
-/// Lift a single chart slug from `/api/groups`, picking from a group whose
-/// name matches `predicate`. Used by tests that need a real slug to drive
-/// `/chart/{slug}` and `/api/chart/{slug}` round-trips.
-pub(crate) async fn pick_chart_slug(
-    server: &Server,
-    predicate: impl Fn(&str) -> bool,
-) -> Result<String> {
-    let client = reqwest::Client::new();
-    let groups: Value = client
-        .get(server.url("/api/groups"))
-        .send()
-        .await?
-        .json()
-        .await?;
-    groups["groups"]
-        .as_array()
-        .context("groups is array")?
-        .iter()
-        .find(|g| g["name"].as_str().is_some_and(&predicate))
-        .and_then(|g| g["charts"].as_array())
-        .and_then(|c| c.first())
-        .and_then(|c| c["slug"].as_str())
-        .map(str::to_string)
-        .context("matching chart slug")
-}
-
-/// Lift a single group slug from `/api/groups`, picking the first group
-/// whose name matches `predicate`.
-pub(crate) async fn pick_group_slug(
-    server: &Server,
-    predicate: impl Fn(&str) -> bool,
-) -> Result<String> {
-    let client = reqwest::Client::new();
-    let groups: Value = client
-        .get(server.url("/api/groups"))
-        .send()
-        .await?
-        .json()
-        .await?;
-    groups["groups"]
-        .as_array()
-        .context("groups is array")?
-        .iter()
-        .find(|g| g["name"].as_str().is_some_and(&predicate))
-        .and_then(|g| g["slug"].as_str())
-        .map(str::to_string)
-        .context("matching group slug")
-}
-
-/// Look up a group entry by its `name` field inside an `/api/groups`
-/// response.
-pub(crate) fn group_by_name<'a>(groups: &'a Value, name: &str) -> Result<&'a Value> {
-    groups["groups"]
-        .as_array()
-        .context("groups is array")?
-        .iter()
-        .find(|g| g["name"].as_str() == Some(name))
-        .with_context(|| format!("group {name:?} exists"))
-}
-
-/// Fuzzy `f64` equality for test assertions. The summary rollups round-trip
-/// through SQL so exact equality isn't safe even on integer-valued inputs.
-pub(crate) fn assert_close(actual: f64, expected: f64) {
-    let delta = (actual - expected).abs();
-    assert!(
-        delta < 0.000_001,
-        "expected {actual} to be close to {expected}"
-    );
-}
-
-/// Pull just the `<div class="filter-dropdown" …>…</div>` substring of the
-/// filter dropdown - its trigger button and the chip panel. Keeps the
-/// snapshot focused on the chip markup and stable against changes elsewhere
-/// on the page.
-pub(crate) fn filter_bar_section(body: &str) -> String {
-    let needle = r#"<div class="filter-dropdown" data-role="global-filter-bar""#;
-    let Some(start) = body.find(needle) else {
-        return "<missing filter bar>".to_string();
-    };
-    let tail = &body[start..];
-    // The dropdown is `<div ...><button>...</button><div class="filter-panel">...</div></div>`.
-    // We need to find the matching `</div>` for the outer wrapper. The
-    // simplest robust approach is to scan and balance.
-    let bytes = tail.as_bytes();
-    let mut depth = 0usize;
-    let mut i = 0usize;
-    while i < bytes.len() {
-        if bytes[i] == b'<' {
-            if tail[i..].starts_with("<div") {
-                depth += 1;
-                i += 4;
-                continue;
-            }
-            if tail[i..].starts_with("</div>") {
-                depth -= 1;
-                if depth == 0 {
-                    return tail[..i + "</div>".len()].to_string();
-                }
-                i += "</div>".len();
-                continue;
-            }
-        }
-        i += 1;
-    }
-    tail.to_string()
-}
-
-/// Pull the `<div class="global-filter-row">` containing chips for one
-/// dimension (`"engine"` or `"format"`).
-pub(crate) fn filter_section(body: &str, dim: &str) -> String {
-    let bar = filter_bar_section(body);
-    let needle = format!(r#"data-filter="{dim}""#);
-    let Some(_) = bar.find(&needle) else {
-        return String::new();
-    };
-    // Walk back to the enclosing `<div class="global-filter-row">`.
-    let row_open = r#"<div class="global-filter-row">"#;
-    let row_close = "</div>";
-    bar.split(row_open)
-        .find(|chunk| chunk.contains(&needle))
-        .and_then(|chunk| chunk.split(row_close).next())
-        .map(str::to_string)
-        .unwrap_or_default()
-}
-
-/// Pull a single chip's opening tag for assertions.
-pub(crate) fn extract_chip(section: &str, value: &str) -> String {
-    let needle = format!(r#"data-value="{value}""#);
-    let Some(idx) = section.find(&needle) else {
-        return String::new();
-    };
-    let head = &section[..idx];
-    let chip_start = head.rfind("<button").unwrap_or(0);
-    let tail = &section[chip_start..];
-    let chip_end = tail.find('>').map(|p| p + 1).unwrap_or(tail.len());
-    tail[..chip_end].to_string()
-}
diff --git a/benchmarks-website/server/tests/group_api.rs b/benchmarks-website/server/tests/group_api.rs
deleted file mode 100644
index dbc33473c07..00000000000
--- a/benchmarks-website/server/tests/group_api.rs
+++ /dev/null
@@ -1,290 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Integration tests for `/group/{slug}` and `/api/group/{slug}` plus the
-//! v2-compatible group summary contract on `/api/groups`.
-
-mod common;
-
-use anyhow::Context as _;
-use anyhow::Result;
-use serde_json::Value;
-
-use self::common::Server;
-use self::common::assert_close;
-use self::common::attr_value;
-use self::common::group_by_name;
-use self::common::insta_settings;
-use self::common::pick_group_slug;
-use self::common::seed;
-use self::common::seed_long_history;
-
-#[tokio::test]
-async fn group_page_snapshot() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let client = reqwest::Client::new();
-    let slug = pick_group_slug(&server, |s| s.starts_with("TPC-H")).await?;
-
-    let resp = client
-        .get(server.url(&format!("/group/{slug}")))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    let body = resp.text().await?;
-    assert!(
-        !body.contains(r#"id="chart-data-0""#),
-        "group page should hydrate through materialized shards, not inline chart payloads"
-    );
-    assert!(
-        body.contains(r#"data-artifact-generation="#)
-            && body.contains(r#"data-group-shard-prefix="#)
-            && body.contains(r#"open"#),
-        "group page should render an open shard-hydrated group shell"
-    );
-    assert!(
-        body.contains(r#"class="toolbar toolbar--card""#),
-        "per-chart toolbar must be rendered on group page"
-    );
-    insta_settings().bind(|| {
-        insta::assert_snapshot!("group_page_query", body);
-    });
-    Ok(())
-}
-
-#[tokio::test]
-async fn group_api_returns_charts() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let slug = pick_group_slug(&server, |s| s.starts_with("TPC-H")).await?;
-
-    let client = reqwest::Client::new();
-    let resp = client
-        .get(server.url(&format!("/api/group/{slug}")))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    let body: Value = resp.json().await?;
-    let charts = body["charts"].as_array().context("charts is array")?;
-    assert!(!charts.is_empty(), "group must have at least one chart");
-    let first = &charts[0];
-    assert!(first["slug"].as_str().is_some(), "chart slug present");
-    assert!(first["name"].as_str().is_some(), "chart name present");
-    assert!(
-        first["commits"].as_array().is_some(),
-        "embedded chart commits"
-    );
-    assert!(
-        first["series"].as_object().is_some(),
-        "embedded chart series"
-    );
-    assert_eq!(
-        body["summary"]["type"].as_str(),
-        Some("queryBenchmark"),
-        "group API should include the server-computed summary"
-    );
-    Ok(())
-}
-
-#[tokio::test]
-async fn group_api_respects_commit_window() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let slug = pick_group_slug(&server, |s| s.starts_with("TPC-H")).await?;
-
-    let client = reqwest::Client::new();
-    let resp = client
-        .get(server.url(&format!("/api/group/{slug}?n=1")))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    let body: Value = resp.json().await?;
-    let charts = body["charts"].as_array().context("charts is array")?;
-    assert!(!charts.is_empty(), "group must have at least one chart");
-    for chart in charts {
-        let commits = chart["commits"].as_array().context("commits is array")?;
-        assert!(
-            commits.len() <= 1,
-            "group hydration should honor the requested commit window"
-        );
-        assert!(chart["series"].as_object().is_some(), "series is present");
-    }
-    Ok(())
-}
-
-#[tokio::test]
-async fn group_shard_artifact_returns_bounded_chart_payloads() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let client = reqwest::Client::new();
-    let landing = client.get(server.url("/")).send().await?.text().await?;
-    let generation = attr_value(&landing, "data-artifact-generation")
-        .context("landing exposes artifact generation")?;
-    let group_slug =
-        attr_value(&landing, "data-group-slug").context("landing exposes group slug")?;
-
-    let resp = client
-        .get(server.url(&format!(
-            "/api/artifacts/{generation}/groups/{group_slug}/shards/0"
-        )))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    let etag = resp
-        .headers()
-        .get(reqwest::header::ETAG)
-        .and_then(|v| v.to_str().ok())
-        .unwrap_or_default()
-        .to_string();
-    assert!(!etag.is_empty(), "artifact response should carry an ETag");
-    let vary = resp
-        .headers()
-        .get(reqwest::header::VARY)
-        .and_then(|v| v.to_str().ok())
-        .unwrap_or_default()
-        .to_ascii_lowercase();
-    assert!(
-        vary.contains("accept-encoding"),
-        "artifact response should vary on Accept-Encoding"
-    );
-
-    let body: Value = resp.json().await?;
-    assert_eq!(body["window"].as_u64(), Some(100));
-    assert_eq!(body["shard_index"].as_u64(), Some(0));
-    assert!(
-        body["shard_count"].as_u64().unwrap_or_default() >= 1,
-        "shard count should be present"
-    );
-    let charts = body["charts"].as_array().context("charts is array")?;
-    assert!(!charts.is_empty(), "first shard should include charts");
-    assert!(charts.len() <= 8, "shards should carry at most 8 charts");
-    for chart in charts {
-        let commits = chart["commits"].as_array().context("commits is array")?;
-        assert!(
-            commits.len() <= 100,
-            "artifact hydration should use the latest-100 window"
-        );
-        assert!(chart["series"].as_object().is_some(), "series is present");
-    }
-    Ok(())
-}
-
-#[tokio::test]
-async fn group_shard_artifact_carries_chart_history_metadata() -> Result<()> {
-    let server = Server::start().await?;
-    seed_long_history(&server, 125).await?;
-
-    let client = reqwest::Client::new();
-    let landing = client.get(server.url("/")).send().await?.text().await?;
-    let generation = attr_value(&landing, "data-artifact-generation")
-        .context("landing exposes artifact generation")?;
-    let group_slug =
-        attr_value(&landing, "data-group-slug").context("landing exposes group slug")?;
-
-    let body: Value = client
-        .get(server.url(&format!(
-            "/api/artifacts/{generation}/groups/{group_slug}/shards/0"
-        )))
-        .send()
-        .await?
-        .json()
-        .await?;
-    let first_chart = body["charts"][0]
-        .as_object()
-        .context("first chart in shard")?;
-    assert_eq!(
-        first_chart["commits"].as_array().map(Vec::len),
-        Some(100),
-        "group shard remains a latest-100 payload"
-    );
-    assert_eq!(first_chart["history"]["total_commits"].as_u64(), Some(125));
-    assert_eq!(first_chart["history"]["start_index"].as_u64(), Some(25));
-    assert_eq!(first_chart["history"]["loaded_commits"].as_u64(), Some(100));
-    assert_eq!(first_chart["history"]["complete"].as_bool(), Some(false));
-    Ok(())
-}
-
-#[tokio::test]
-async fn unknown_group_shard_artifact_returns_404() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let client = reqwest::Client::new();
-    let resp = client
-        .get(server.url("/api/artifacts/not-a-generation/groups/not-a-group/shards/0"))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 404);
-    Ok(())
-}
-
-#[tokio::test]
-async fn group_summaries_match_v2_contract() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let client = reqwest::Client::new();
-    let groups: Value = client
-        .get(server.url("/api/groups"))
-        .send()
-        .await?
-        .json()
-        .await?;
-
-    let random_access = &group_by_name(&groups, "Random Access")?["summary"];
-    assert_eq!(random_access["type"].as_str(), Some("randomAccess"));
-    let rankings = random_access["rankings"]
-        .as_array()
-        .context("random access rankings")?;
-    assert_eq!(rankings[0]["name"].as_str(), Some("vortex-file-compressed"));
-    assert_eq!(rankings[1]["name"].as_str(), Some("parquet"));
-    assert_close(rankings[1]["ratio"].as_f64().context("random ratio")?, 2.0);
-
-    let compression = &group_by_name(&groups, "Compression")?["summary"];
-    assert_eq!(compression["type"].as_str(), Some("compression"));
-    assert_close(
-        compression["compressRatio"]
-            .as_f64()
-            .context("compressRatio")?,
-        2.0,
-    );
-    assert_close(
-        compression["decompressRatio"]
-            .as_f64()
-            .context("decompressRatio")?,
-        2.0,
-    );
-    assert_eq!(compression["datasetCount"].as_u64(), Some(1));
-
-    let compression_size = &group_by_name(&groups, "Compression Size")?["summary"];
-    assert_eq!(compression_size["type"].as_str(), Some("compressionSize"));
-    assert_close(
-        compression_size["meanRatio"]
-            .as_f64()
-            .context("meanRatio")?,
-        0.5,
-    );
-    assert_eq!(compression_size["datasetCount"].as_u64(), Some(1));
-
-    let query = &group_by_name(&groups, "TPC-H (NVMe) (SF=1)")?["summary"];
-    assert_eq!(query["type"].as_str(), Some("queryBenchmark"));
-    let rankings = query["rankings"].as_array().context("query rankings")?;
-    assert_eq!(
-        rankings[0]["name"].as_str(),
-        Some("datafusion:vortex-file-compressed"),
-        "query summary should include v2's missing-series penalty"
-    );
-    assert_eq!(rankings[1]["name"].as_str(), Some("duckdb:parquet"));
-    let first_score = rankings[0]["score"].as_f64().context("first score")?;
-    let second_score = rankings[1]["score"].as_f64().context("second score")?;
-    assert!(
-        first_score < second_score,
-        "lower query score should rank first"
-    );
-
-    Ok(())
-}
diff --git a/benchmarks-website/server/tests/ingest.rs b/benchmarks-website/server/tests/ingest.rs
deleted file mode 100644
index ba4af6e29b4..00000000000
--- a/benchmarks-website/server/tests/ingest.rs
+++ /dev/null
@@ -1,385 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Integration tests for `POST /api/ingest` — round-trips the bearer
-//! check, the all-or-nothing transaction, the schema-version gate, and
-//! the upsert path.
-
-use std::net::SocketAddr;
-
-use anyhow::Context as _;
-use anyhow::Result;
-use serde_json::Value;
-use serde_json::json;
-use tempfile::TempDir;
-use tokio::net::TcpListener;
-use tokio::task::JoinHandle;
-use tokio::time::Duration;
-use vortex_bench_server::app::AppState;
-use vortex_bench_server::app::router;
-
-const TOKEN: &str = "test-bearer-token";
-
-struct Server {
-    addr: SocketAddr,
-    _tmp: TempDir,
-    handle: JoinHandle<()>,
-}
-
-impl Server {
-    async fn start() -> Result<Self> {
-        let tmp = TempDir::new()?;
-        let db_path = tmp.path().join("bench.duckdb");
-        let state = AppState::open(&db_path, TOKEN.to_string())?;
-        let app = router(state);
-
-        let listener = TcpListener::bind("127.0.0.1:0").await?;
-        let addr = listener.local_addr()?;
-        let handle = tokio::spawn(async move {
-            axum::serve(listener, app).await.unwrap();
-        });
-        Ok(Self {
-            addr,
-            _tmp: tmp,
-            handle,
-        })
-    }
-
-    fn url(&self, path: &str) -> String {
-        format!("http://{}{}", self.addr, path)
-    }
-}
-
-impl Drop for Server {
-    fn drop(&mut self) {
-        self.handle.abort();
-    }
-}
-
-async fn wait_for_groups(client: &reqwest::Client, server: &Server) -> Result<Value> {
-    let mut last_len = 0usize;
-    for _ in 0..100 {
-        let resp = client.get(server.url("/api/groups")).send().await?;
-        assert_eq!(resp.status(), 200);
-        let body: Value = resp.json().await?;
-        last_len = body["groups"].as_array().context("groups is array")?.len();
-        if last_len > 0 {
-            return Ok(body);
-        }
-        tokio::time::sleep(Duration::from_millis(25)).await;
-    }
-    anyhow::bail!("read model did not rebuild groups; last len {last_len}")
-}
-
-fn fixture_envelope() -> Value {
-    let raw = include_str!("../fixtures/envelope.json");
-    serde_json::from_str(raw).expect("fixture envelope is valid JSON")
-}
-
-#[tokio::test]
-async fn happy_path_then_idempotent_reingest() -> Result<()> {
-    let server = Server::start().await?;
-    let client = reqwest::Client::new();
-    let envelope = fixture_envelope();
-
-    let resp = client
-        .post(server.url("/api/ingest"))
-        .bearer_auth(TOKEN)
-        .json(&envelope)
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200, "first ingest should be 200");
-    let body: Value = resp.json().await?;
-    assert_eq!(body["inserted"].as_u64(), Some(5));
-    assert_eq!(body["updated"].as_u64(), Some(0));
-
-    let resp = client
-        .post(server.url("/api/ingest"))
-        .bearer_auth(TOKEN)
-        .json(&envelope)
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200, "second ingest should be 200");
-    let body: Value = resp.json().await?;
-    assert_eq!(body["inserted"].as_u64(), Some(0), "no new rows on re-emit");
-    assert!(
-        body["updated"].as_u64().context("updated is u64")? > 0,
-        "re-emit must report at least one updated row"
-    );
-    Ok(())
-}
-
-#[tokio::test]
-async fn accepts_payloads_above_axum_default_body_limit() -> Result<()> {
-    let server = Server::start().await?;
-    let client = reqwest::Client::new();
-    let mut envelope = fixture_envelope();
-    envelope["commit"]["message"] = json!("x".repeat(3 * 1024 * 1024));
-
-    let resp = client
-        .post(server.url("/api/ingest"))
-        .bearer_auth(TOKEN)
-        .json(&envelope)
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    Ok(())
-}
-
-#[tokio::test]
-async fn missing_bearer_is_unauthorized() -> Result<()> {
-    let server = Server::start().await?;
-    let client = reqwest::Client::new();
-    let envelope = fixture_envelope();
-
-    let resp = client
-        .post(server.url("/api/ingest"))
-        .json(&envelope)
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 401);
-    Ok(())
-}
-
-#[tokio::test]
-async fn wrong_bearer_is_unauthorized() -> Result<()> {
-    let server = Server::start().await?;
-    let client = reqwest::Client::new();
-    let envelope = fixture_envelope();
-
-    let resp = client
-        .post(server.url("/api/ingest"))
-        .bearer_auth("not-the-real-token")
-        .json(&envelope)
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 401);
-    Ok(())
-}
-
-#[tokio::test]
-async fn unknown_kind_is_400() -> Result<()> {
-    let server = Server::start().await?;
-    let client = reqwest::Client::new();
-
-    let envelope = json!({
-        "run_meta": {
-            "benchmark_id": "fixture",
-            "schema_version": 1,
-            "started_at": "2026-04-25T00:00:00Z"
-        },
-        "commit": {
-            "sha": "0123456789abcdef0123456789abcdef01234567",
-            "timestamp": "2026-04-25T00:00:00Z",
-            "message": "x", "author_name": "x", "author_email": "x@x",
-            "committer_name": "x", "committer_email": "x@x",
-            "tree_sha": "fedcba9876543210fedcba9876543210fedcba98",
-            "url": "https://example.com"
-        },
-        "records": [
-            { "kind": "made_up_kind", "commit_sha": "0123456789abcdef0123456789abcdef01234567" }
-        ]
-    });
-    let resp = client
-        .post(server.url("/api/ingest"))
-        .bearer_auth(TOKEN)
-        .json(&envelope)
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 400);
-    Ok(())
-}
-
-#[tokio::test]
-async fn unknown_field_is_400() -> Result<()> {
-    let server = Server::start().await?;
-    let client = reqwest::Client::new();
-
-    let mut envelope = fixture_envelope();
-    envelope["records"][0]["surprise_field"] = json!("oops");
-    let resp = client
-        .post(server.url("/api/ingest"))
-        .bearer_auth(TOKEN)
-        .json(&envelope)
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 400);
-    Ok(())
-}
-
-#[tokio::test]
-async fn schema_version_too_new_is_409() -> Result<()> {
-    let server = Server::start().await?;
-    let client = reqwest::Client::new();
-
-    let mut envelope = fixture_envelope();
-    envelope["run_meta"]["schema_version"] = json!(99);
-    let resp = client
-        .post(server.url("/api/ingest"))
-        .bearer_auth(TOKEN)
-        .json(&envelope)
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 409);
-    Ok(())
-}
-
-#[tokio::test]
-async fn invalid_storage_is_400_record_error() -> Result<()> {
-    let server = Server::start().await?;
-    let client = reqwest::Client::new();
-
-    let mut envelope = fixture_envelope();
-    envelope["records"][0]["storage"] = json!("gcs");
-    let resp = client
-        .post(server.url("/api/ingest"))
-        .bearer_auth(TOKEN)
-        .json(&envelope)
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 400);
-    let body: Value = resp.json().await?;
-    assert_eq!(body["record_index"], json!(0));
-    Ok(())
-}
-
-#[tokio::test]
-async fn health_reports_after_ingest() -> Result<()> {
-    let server = Server::start().await?;
-    let client = reqwest::Client::new();
-
-    // Pre-ingest: counts are zero.
-    let resp = client.get(server.url("/health")).send().await?;
-    assert_eq!(resp.status(), 200);
-    let body: Value = resp.json().await?;
-    assert_eq!(body["status"], "ok");
-    assert_eq!(body["schema_version"], 1);
-    assert_eq!(body["row_counts"]["commits"], 0);
-    assert!(body["latest_commit_timestamp"].is_null());
-
-    // Ingest, then re-check.
-    client
-        .post(server.url("/api/ingest"))
-        .bearer_auth(TOKEN)
-        .json(&fixture_envelope())
-        .send()
-        .await?;
-
-    let resp = client.get(server.url("/health")).send().await?;
-    let body: Value = resp.json().await?;
-    assert_eq!(body["row_counts"]["commits"], 1);
-    assert_eq!(body["row_counts"]["query_measurements"], 1);
-    assert_eq!(body["row_counts"]["compression_times"], 1);
-    assert_eq!(body["row_counts"]["compression_sizes"], 1);
-    assert_eq!(body["row_counts"]["random_access_times"], 1);
-    assert_eq!(body["row_counts"]["vector_search_runs"], 1);
-    assert!(!body["latest_commit_timestamp"].is_null());
-    Ok(())
-}
-
-#[tokio::test]
-async fn read_routes_serve_after_ingest() -> Result<()> {
-    let server = Server::start().await?;
-    let client = reqwest::Client::new();
-
-    client
-        .post(server.url("/api/ingest"))
-        .bearer_auth(TOKEN)
-        .json(&fixture_envelope())
-        .send()
-        .await?;
-
-    let body = wait_for_groups(&client, &server).await?;
-    let groups = body["groups"].as_array().context("groups is array")?;
-    assert!(
-        !groups.is_empty(),
-        "groups should not be empty after ingest"
-    );
-
-    // Pick the first chart slug and round-trip it.
-    let first_chart = groups
-        .iter()
-        .find_map(|g| g["charts"].as_array().and_then(|c| c.first()))
-        .context("at least one chart")?;
-    let slug = first_chart["slug"]
-        .as_str()
-        .context("slug is a string")?
-        .to_string();
-
-    let resp = client
-        .get(server.url(&format!("/api/chart/{slug}")))
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200, "chart {slug} should resolve");
-    let body: Value = resp.json().await?;
-    assert!(body["display_name"].is_string());
-    assert!(body["unit_kind"].is_string());
-    assert!(body["commits"].is_array());
-    assert_eq!(
-        body["commits"]
-            .as_array()
-            .context("commits is array")?
-            .len(),
-        1
-    );
-    assert!(body["series"].is_object());
-    Ok(())
-}
-
-#[tokio::test]
-async fn unknown_slug_is_404() -> Result<()> {
-    let server = Server::start().await?;
-    let client = reqwest::Client::new();
-
-    let resp = client
-        .get(server.url("/api/chart/qm.aGVsbG8"))
-        .send()
-        .await?;
-    // Either 400 (couldn't decode JSON) or 404 (decoded but no rows). Both are
-    // acceptable per the contract; we just need it to not be a 500.
-    assert!(
-        resp.status() == 400 || resp.status() == 404,
-        "got {}",
-        resp.status()
-    );
-    Ok(())
-}
-
-/// Reads are served from the materialized read model. Ingest schedules a
-/// background rebuild and keeps the old generation live until the new one is
-/// ready.
-#[tokio::test]
-async fn read_model_rebuilds_after_ingest() -> Result<()> {
-    let server = Server::start().await?;
-    let client = reqwest::Client::new();
-
-    // Warm the cache against an empty DB.
-    let resp = client.get(server.url("/api/groups")).send().await?;
-    assert_eq!(resp.status(), 200);
-    let body: Value = resp.json().await?;
-    assert_eq!(
-        body["groups"].as_array().context("groups is array")?.len(),
-        0,
-        "groups should be empty before any ingest"
-    );
-
-    // Ingest some data. The handler invalidates fallback caches and schedules
-    // the materialized read-model rebuild after the commit.
-    let resp = client
-        .post(server.url("/api/ingest"))
-        .bearer_auth(TOKEN)
-        .json(&fixture_envelope())
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200, "ingest should succeed");
-
-    // The old empty generation may be served briefly, but the rebuilt
-    // generation must become visible shortly after ingest.
-    let body = wait_for_groups(&client, &server).await?;
-    let groups = body["groups"].as_array().context("groups is array")?;
-    assert!(
-        !groups.is_empty(),
-        "groups must repopulate after the read-model rebuild"
-    );
-    Ok(())
-}
diff --git a/benchmarks-website/server/tests/landing.rs b/benchmarks-website/server/tests/landing.rs
deleted file mode 100644
index 213b92576c9..00000000000
--- a/benchmarks-website/server/tests/landing.rs
+++ /dev/null
@@ -1,518 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Integration tests for the landing page (`GET /`).
-
-mod common;
-
-use anyhow::Context as _;
-use anyhow::Result;
-use serde_json::Value;
-
-use self::common::Server;
-use self::common::attr_value;
-use self::common::extract_chip;
-use self::common::filter_bar_section;
-use self::common::filter_section;
-use self::common::insta_settings;
-use self::common::pick_chart_slug;
-use self::common::pick_group_slug;
-use self::common::seed;
-use self::common::seed_long_history;
-
-#[tokio::test]
-async fn landing_page_snapshot() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let client = reqwest::Client::new();
-    let resp = client.get(server.url("/")).send().await?;
-    assert_eq!(resp.status(), 200);
-    let content_type = resp
-        .headers()
-        .get(reqwest::header::CONTENT_TYPE)
-        .and_then(|v| v.to_str().ok())
-        .unwrap_or("");
-    assert!(
-        content_type.starts_with("text/html"),
-        "expected text/html, got {content_type:?}"
-    );
-    let body = resp.text().await?;
-
-    // Canvas shells render immediately, but chart data comes from
-    // versioned group shard artifacts instead of inline JSON.
-    assert!(
-        body.contains("<canvas"),
-        "landing page must render at least one <canvas>"
-    );
-    assert!(
-        !body.contains(r#"id="chart-data-0""#),
-        "landing page should not inline chart payloads"
-    );
-    assert!(
-        body.contains(r#"data-chart-slug="#),
-        "every chart card carries data-chart-slug for the lazy-fetch path"
-    );
-    assert!(
-        body.contains(r#"data-group-slug="#),
-        "every group carries data-group-slug as stable metadata"
-    );
-    assert!(
-        body.contains(r#"data-artifact-generation="#)
-            && body.contains(r#"data-group-shard-count="#)
-            && body.contains(r#"data-group-shard-prefix="#),
-        "every group should carry versioned shard hydration metadata"
-    );
-    assert!(
-        attr_value(&body, "data-artifact-generation").is_some_and(|v| !v.is_empty()),
-        "artifact generation should be non-empty"
-    );
-    assert!(
-        !body.contains(r#"id="group-search""#),
-        "landing page should not render the old group search bar"
-    );
-    assert!(
-        body.contains(r#"class="sticky-header""#),
-        "landing page should render the v2-style top navbar"
-    );
-    assert!(
-        body.contains(r#"data-action="expand-all""#)
-            && body.contains(r#"data-action="collapse-all""#),
-        "navbar should expose expand/collapse controls"
-    );
-    assert!(
-        body.contains(r#"data-role="theme-toggle""#),
-        "navbar should expose a theme toggle"
-    );
-    assert!(
-        body.contains(r#"class="btn-icon""#)
-            || body.contains(r#"class="btn-icon theme-icon theme-icon-light""#),
-        "navbar controls should render icons"
-    );
-    assert!(
-        body.contains(r#"Vortex_Black_NoBG.png"#) && body.contains(r#"Vortex_White_NoBG.png"#),
-        "navbar should render the Vortex logo assets"
-    );
-    assert!(
-        body.contains("⚡") && body.contains("📤") && body.contains("⬇️") && body.contains("📊"),
-        "summaries should render the v2 summary icons"
-    );
-
-    insta_settings().bind(|| {
-        insta::assert_snapshot!("landing_page", body);
-    });
-    Ok(())
-}
-
-/// All group disclosures render closed by default — the user picks which
-/// to expand. Chart payloads are intentionally not inlined; the disclosure
-/// carries shard metadata so JS can fetch the materialized latest-100
-/// artifact on intent/open.
-#[tokio::test]
-async fn details_all_groups_closed_by_default() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let client = reqwest::Client::new();
-    let body = client.get(server.url("/")).send().await?.text().await?;
-
-    let opens: Vec<_> = body
-        .match_indices(r#"<details class="group-disclosure""#)
-        .map(|(i, _)| {
-            let tag_end = body[i..].find('>').map(|p| i + p).unwrap_or(i);
-            body[i..=tag_end].contains(" open")
-        })
-        .collect();
-    assert!(!opens.is_empty(), "landing page must render <details>");
-    for (i, is_open) in opens.iter().enumerate() {
-        assert!(!is_open, "group #{i} must be closed by default");
-    }
-    assert!(
-        !body.contains(r#"id="chart-data-0""#),
-        "landing page should hydrate charts from materialized artifacts",
-    );
-    assert!(
-        body.contains(r#"data-group-shard-count="#),
-        "closed groups should still carry shard metadata",
-    );
-    Ok(())
-}
-
-#[tokio::test]
-async fn collapsed_groups_still_show_summaries() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let client = reqwest::Client::new();
-    let body = client.get(server.url("/")).send().await?.text().await?;
-
-    let mut found_visible_summary = false;
-    for (group_start, _) in body.match_indices(r#"<section class="group-details""#) {
-        let details_start = body[group_start..]
-            .find(r#"<details class="group-disclosure""#)
-            .map(|p| group_start + p)
-            .context("group contains disclosure")?;
-        let details_tag_end = body[details_start..]
-            .find('>')
-            .map(|p| details_start + p)
-            .context("details tag closes")?;
-        let is_open = body[details_start..=details_tag_end].contains(" open");
-        if is_open {
-            continue;
-        }
-
-        let summary_end = body[details_start..]
-            .find("</details>")
-            .map(|p| details_start + p)
-            .context("disclosure closes")?;
-        let chart_grid_start = body[summary_end..]
-            .find(r#"<div class="chart-grid">"#)
-            .map(|p| summary_end + p)
-            .context("details contains chart grid")?;
-        let visible_region = &body[summary_end..chart_grid_start];
-        if visible_region.contains(r#"class="benchmark-scores-summary""#) {
-            found_visible_summary = true;
-            break;
-        }
-    }
-
-    assert!(
-        found_visible_summary,
-        "at least one closed group should render its score summary before the hidden chart grid"
-    );
-    Ok(())
-}
-
-/// Every `.chart-card` carries a compact `.toolbar.toolbar--card` so the user
-/// has per-chart controls. There is no page-level toolbar, no preset scope
-/// button row, and no abs/rel mode toggle.
-#[tokio::test]
-async fn chart_card_carries_per_chart_toolbar() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let client = reqwest::Client::new();
-    let body = client.get(server.url("/")).send().await?.text().await?;
-
-    let card_count = body.matches(r#"<section class="chart-card""#).count();
-    let toolbar_count = body.matches(r#"class="toolbar toolbar--card""#).count();
-    let strip_count = body.matches(r#"data-role="range-strip""#).count();
-    assert!(card_count > 0, "landing page must render chart cards");
-    assert_eq!(
-        toolbar_count, card_count,
-        "every chart-card must contain a toolbar--card ({card_count} cards / {toolbar_count} toolbars)"
-    );
-    assert_eq!(
-        strip_count, card_count,
-        "every chart-card must carry a range-strip below the canvas \
-         ({card_count} cards / {strip_count} strips)"
-    );
-    assert!(
-        body.contains(r#"data-role="range-window""#)
-            && body.contains(r#"data-role="range-handle-left""#)
-            && body.contains(r#"data-role="range-handle-right""#),
-        "range-strip must include a draggable window and two resize handles"
-    );
-    assert!(
-        !body.contains(r#"data-mode="#),
-        "abs/rel mode buttons should not render"
-    );
-    assert!(
-        !body.contains(r#"data-scope="#),
-        "preset scope buttons should not render; use the slider instead"
-    );
-    assert!(
-        body.contains(r#"data-role="scope-slider""#),
-        "scope slider should remain available"
-    );
-    assert!(
-        !body.contains(r#"scope-slider-label"#),
-        "scope value labels should not add repeated numbers to every card"
-    );
-
-    // Same invariant on /chart/{slug}.
-    let slug = pick_chart_slug(&server, |s| s.starts_with("TPC-H")).await?;
-    let body = client
-        .get(server.url(&format!("/chart/{slug}")))
-        .send()
-        .await?
-        .text()
-        .await?;
-    assert!(
-        body.contains(r#"class="toolbar toolbar--card""#),
-        "chart page must carry a per-chart toolbar"
-    );
-    assert!(!body.contains(r#"data-mode="#));
-    assert!(!body.contains(r#"data-scope="#));
-    assert!(body.contains(r#"data-role="scope-slider""#));
-    assert!(!body.contains(r#"scope-slider-label"#));
-
-    // Same invariant on /group/{slug}.
-    let group_slug = pick_group_slug(&server, |s| s.starts_with("TPC-H")).await?;
-    let body = client
-        .get(server.url(&format!("/group/{group_slug}")))
-        .send()
-        .await?
-        .text()
-        .await?;
-    assert!(
-        body.contains(r#"class="toolbar toolbar--card""#),
-        "group page must carry per-chart toolbars"
-    );
-    assert!(!body.contains(r#"data-mode="#));
-    assert!(!body.contains(r#"data-scope="#));
-    assert!(body.contains(r#"data-role="scope-slider""#));
-    assert!(!body.contains(r#"scope-slider-label"#));
-    Ok(())
-}
-
-/// Landing-page `<details>` summaries appear in the canonical v2 order: the
-/// fixture seeds Random Access, Compression, Compression Size, TPC-H, and a
-/// vector-search group. The first three are in `api::GROUP_ORDER` in the
-/// expected positions; TPC-H follows; the unknown vector-search group sorts
-/// last (alphabetical fallback after the listed names).
-#[tokio::test]
-async fn landing_groups_render_in_v2_order() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let client = reqwest::Client::new();
-    let body = client.get(server.url("/")).send().await?.text().await?;
-
-    // Extract group names in render order from the `data-group-name=` attrs.
-    let mut names = Vec::new();
-    for window in body.split("data-group-name=\"").skip(1) {
-        if let Some(end) = window.find('"') {
-            names.push(window[..end].to_string());
-        }
-    }
-    let expected = [
-        "Random Access",
-        "Compression",
-        "Compression Size",
-        "TPC-H (NVMe) (SF=1)",
-        "cohere-large-10m / partitioned",
-    ];
-    assert_eq!(names, expected, "v2 ordering");
-    Ok(())
-}
-
-#[tokio::test]
-async fn empty_landing_page_renders() -> Result<()> {
-    let server = Server::start().await?;
-    let client = reqwest::Client::new();
-
-    let resp = client.get(server.url("/")).send().await?;
-    assert_eq!(resp.status(), 200);
-    let body = resp.text().await?;
-    assert!(body.contains("No data ingested yet"));
-    Ok(())
-}
-
-/// Landing page renders the global filter dropdown inside the sticky
-/// header, with chip rows for engine and format sourced from the seeded
-/// data — no hard-coding.
-#[tokio::test]
-async fn landing_page_renders_global_filter_bar() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let client = reqwest::Client::new();
-    let body = client.get(server.url("/")).send().await?.text().await?;
-
-    // The dropdown lives inside the sticky header so it stays on-screen
-    // while the user scrolls.
-    let header_chunk = body
-        .split(r#"class="sticky-header""#)
-        .nth(1)
-        .and_then(|s| s.split("</header>").next())
-        .context("sticky header chunk")?;
-    assert!(
-        header_chunk.contains(r#"data-role="global-filter-bar""#),
-        "filter dropdown must live inside the sticky header"
-    );
-    assert!(header_chunk.contains(r#"data-role="filter-trigger""#));
-    assert!(header_chunk.contains(r#"data-role="filter-panel""#));
-    assert!(header_chunk.contains(r#"data-filter="engine""#));
-    assert!(header_chunk.contains(r#"data-filter="format""#));
-    // Engines + formats from the seed fixture must appear as chips.
-    assert!(body.contains(r#"data-value="datafusion""#));
-    assert!(body.contains(r#"data-value="duckdb""#));
-    assert!(body.contains(r#"data-value="vortex-file-compressed""#));
-    assert!(body.contains(r#"data-value="parquet""#));
-    // Both rows have an "all" reset chip.
-    assert!(body.matches(r#"data-value="*""#).count() >= 2);
-    // The "all" chip is now a one-shot reset and is never rendered active —
-    // active chips reflect the visible engine/format set.
-    assert!(
-        !body.contains(r#"class="filter-chip filter-chip--all filter-chip--active""#),
-        "the 'all' chip should never start active"
-    );
-    // No filter applied by default → every specific chip is active.
-    let engine_section = filter_section(&body, "engine");
-    for engine in ["datafusion", "duckdb"] {
-        assert!(
-            extract_chip(&engine_section, engine).contains("filter-chip--active"),
-            "engine chip {engine} should be active when no filter is applied"
-        );
-    }
-    // No badge on the trigger when nothing is hidden.
-    assert!(
-        !body.contains(r#"data-role="filter-badge""#),
-        "filter badge should be absent when no chips are off"
-    );
-    // Embedded filter state JSON for the client to pick up.
-    assert!(body.contains(r#"id="bench-filter-state""#));
-
-    insta_settings().bind(|| {
-        insta::assert_snapshot!("landing_page_filter_bar", filter_bar_section(&body));
-    });
-    Ok(())
-}
-
-/// Landing page honours `?engine=`/`?format=` and reflects them as the
-/// active chip set + initial filter-state JSON, so a refresh preserves view.
-#[tokio::test]
-async fn landing_page_honours_filter_query_params() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let client = reqwest::Client::new();
-    let body = client
-        .get(server.url("/?engine=duckdb&format=vortex-file-compressed"))
-        .send()
-        .await?
-        .text()
-        .await?;
-
-    assert!(
-        body.contains(r#"{"engines":["duckdb"],"formats":["vortex-file-compressed"]}"#),
-        "filter state JSON should reflect query params"
-    );
-    let engine_section = filter_section(&body, "engine");
-    assert!(
-        engine_section.contains(r#"data-value="duckdb""#)
-            && extract_chip(&engine_section, "duckdb").contains("filter-chip--active"),
-        "duckdb chip should be active"
-    );
-    assert!(
-        !extract_chip(&engine_section, "datafusion").contains("filter-chip--active"),
-        "datafusion chip should NOT be active when engine=duckdb"
-    );
-    assert!(
-        !extract_chip(&engine_section, "*").contains("filter-chip--active"),
-        "the 'all' chip is a reset, never active"
-    );
-    // Trigger should show a badge counting the off chips (1 engine + 1 format).
-    assert!(
-        body.contains(r#"data-role="filter-badge""#),
-        "trigger should render a badge when chips are filtered off"
-    );
-    Ok(())
-}
-
-/// The landing page does not inline chart JSON. Its first materialized shard
-/// caps chart payloads at 100 commits regardless of `?n=`; power users get
-/// full history via the explicit `/api/chart/{slug}?n=all` refetch.
-#[tokio::test]
-async fn landing_first_group_shard_caps_commits() -> Result<()> {
-    // 101 commits is the smallest fixture above the 100-commit artifact cap, so the
-    // cap actually kicks in. `seed_long_history` only seeds the Random-Access
-    // group; with the canonical group ordering Random Access sorts first.
-    let server = Server::start().await?;
-    seed_long_history(&server, 101).await?;
-
-    let client = reqwest::Client::new();
-    let body = client.get(server.url("/")).send().await?.text().await?;
-    assert!(
-        !body.contains(r#"id="chart-data-0""#),
-        "landing page should not inline chart JSON"
-    );
-
-    let generation = attr_value(&body, "data-artifact-generation")
-        .context("landing exposes artifact generation")?;
-    let group_slug = attr_value(&body, "data-group-slug").context("landing exposes group slug")?;
-    let shard: Value = client
-        .get(server.url(&format!(
-            "/api/artifacts/{generation}/groups/{group_slug}/shards/0"
-        )))
-        .send()
-        .await?
-        .json()
-        .await?;
-    let commits = shard["charts"][0]["commits"]
-        .as_array()
-        .context("shard chart commits array")?;
-    assert!(
-        commits.len() <= 100,
-        "landing shard must cap commits at 100, \
-         got {}",
-        commits.len(),
-    );
-    // Sanity check: the cap actually fired on this fixture (≥ 100 commits
-    // seeded). Without this we'd silently regress to "always small fixture".
-    assert_eq!(
-        commits.len(),
-        100,
-        "with 101 seeded commits the shard payload should be exactly the \
-         100-commit cap; got {}",
-        commits.len(),
-    );
-
-    // ?n=all on the URL still parses without panicking and still leaves the
-    // landing page as shell-only metadata.
-    let body_all = client
-        .get(server.url("/?n=all"))
-        .send()
-        .await?
-        .text()
-        .await?;
-    assert!(
-        !body_all.contains(r#"id="chart-data-0""#),
-        "?n=all on the landing page must not inline full-history chart data"
-    );
-    Ok(())
-}
-
-/// Sanity smoke test: round-trip every chart slug `/api/groups` returns
-/// through `/chart/{slug}` to make sure each slug shape's HTML route is
-/// wired up.
-#[tokio::test]
-async fn chart_page_round_trips_every_slug() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let client = reqwest::Client::new();
-    let groups: Value = client
-        .get(server.url("/api/groups"))
-        .send()
-        .await?
-        .json()
-        .await?;
-    let slugs: Vec<String> = groups["groups"]
-        .as_array()
-        .context("groups is array")?
-        .iter()
-        .flat_map(|g| g["charts"].as_array().cloned().unwrap_or_default())
-        .filter_map(|c| c["slug"].as_str().map(str::to_string))
-        .collect();
-    anyhow::ensure!(!slugs.is_empty(), "expected at least one chart slug");
-
-    for slug in &slugs {
-        let resp = client
-            .get(server.url(&format!("/chart/{slug}")))
-            .send()
-            .await?;
-        assert_eq!(
-            resp.status(),
-            200,
-            "chart page for slug {slug} should be 200"
-        );
-        let body = resp.text().await?;
-        assert!(
-            body.contains(r#"id="chart-data-0""#),
-            "missing inline chart data for slug {slug}"
-        );
-    }
-    Ok(())
-}
diff --git a/benchmarks-website/server/tests/permalinks.rs b/benchmarks-website/server/tests/permalinks.rs
deleted file mode 100644
index 3b8b3919119..00000000000
--- a/benchmarks-website/server/tests/permalinks.rs
+++ /dev/null
@@ -1,158 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Integration tests for `/chart/{slug}` and `/group/{slug}` permalink
-//! behaviour: full-history payloads, embedded filter state, 404s on
-//! unknown slugs.
-
-mod common;
-
-use anyhow::Context as _;
-use anyhow::Result;
-
-use self::common::Server;
-use self::common::attr_value;
-use self::common::extract_chart_data;
-use self::common::pick_chart_slug;
-use self::common::pick_group_slug;
-use self::common::seed;
-use self::common::seed_long_history;
-
-/// `/chart/{slug}` defaults to the materialized latest-100 window and
-/// upgrades to full raw history only with `?n=all`. `/group/{slug}` renders
-/// shell markup and hydrates the same latest-100 materialized shards as the
-/// landing page.
-#[tokio::test]
-async fn permalink_pages_default_to_latest_100_and_opt_into_full_history() -> Result<()> {
-    let server = Server::start().await?;
-    seed_long_history(&server, 101).await?;
-
-    let chart_slug = pick_chart_slug(&server, |s| s == "Random Access").await?;
-    let group_slug = pick_group_slug(&server, |s| s == "Random Access").await?;
-    let client = reqwest::Client::new();
-
-    let chart_body = client
-        .get(server.url(&format!("/chart/{chart_slug}")))
-        .send()
-        .await?
-        .text()
-        .await?;
-    let chart_payload =
-        extract_chart_data(&chart_body, 0).context("chart inline payload present")?;
-    assert_eq!(
-        chart_payload["commits"]
-            .as_array()
-            .context("commits is array")?
-            .len(),
-        100,
-        "/chart permalink should default to the latest-100 materialized window",
-    );
-
-    let chart_all_body = client
-        .get(server.url(&format!("/chart/{chart_slug}?n=all")))
-        .send()
-        .await?
-        .text()
-        .await?;
-    let chart_all_payload =
-        extract_chart_data(&chart_all_body, 0).context("chart all inline payload present")?;
-    assert_eq!(
-        chart_all_payload["commits"]
-            .as_array()
-            .context("all commits is array")?
-            .len(),
-        101,
-        "/chart?n=all should inline the full raw history",
-    );
-
-    let group_body = client
-        .get(server.url(&format!("/group/{group_slug}")))
-        .send()
-        .await?
-        .text()
-        .await?;
-    assert!(
-        !group_body.contains(r#"id="chart-data-0""#),
-        "/group permalink should not inline chart payloads"
-    );
-    let generation = attr_value(&group_body, "data-artifact-generation")
-        .context("group page exposes artifact generation")?;
-    let shard_prefix = attr_value(&group_body, "data-group-shard-prefix")
-        .context("group page exposes shard prefix")?;
-    let shard_path = shard_prefix
-        .strip_prefix('/')
-        .map(|s| format!("/{s}0"))
-        .context("absolute shard prefix")?;
-    let shard: serde_json::Value = client
-        .get(server.url(&shard_path))
-        .send()
-        .await?
-        .json()
-        .await?;
-    assert_eq!(
-        shard["charts"][0]["commits"]
-            .as_array()
-            .context("shard commits is array")?
-            .len(),
-        100,
-        "/group permalink should hydrate the latest-100 shard",
-    );
-    assert!(
-        shard_path.contains(&generation),
-        "group shard URL should be versioned by generation"
-    );
-
-    Ok(())
-}
-
-/// Permalink pages render the same filter dropdown in the navbar (so the
-/// user can adjust visibility from any page) and embed the filter-state
-/// JSON so chart-init.js applies the filter on hydration.
-#[tokio::test]
-async fn permalink_pages_embed_filter_state() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let client = reqwest::Client::new();
-    let chart_slug = pick_chart_slug(&server, |s| s.starts_with("TPC-H")).await?;
-    let group_slug = pick_group_slug(&server, |s| s.starts_with("TPC-H")).await?;
-
-    let chart_body = client
-        .get(server.url(&format!("/chart/{chart_slug}?engine=duckdb&format=parquet")))
-        .send()
-        .await?
-        .text()
-        .await?;
-    assert!(
-        chart_body.contains(r#"id="bench-filter-state""#),
-        "chart permalink must embed filter state"
-    );
-    assert!(
-        chart_body.contains(r#"{"engines":["duckdb"],"formats":["parquet"]}"#),
-        "chart permalink must echo the query-param filter state"
-    );
-
-    let group_body = client
-        .get(server.url(&format!("/group/{group_slug}?engine=duckdb")))
-        .send()
-        .await?
-        .text()
-        .await?;
-    assert!(
-        group_body.contains(r#"{"engines":["duckdb"],"formats":[]}"#),
-        "group permalink must echo the query-param filter state"
-    );
-    Ok(())
-}
-
-#[tokio::test]
-async fn unknown_slug_renders_404() -> Result<()> {
-    let server = Server::start().await?;
-    let client = reqwest::Client::new();
-
-    let resp = client.get(server.url("/chart/qm.aGVsbG8")).send().await?;
-    assert_eq!(resp.status(), 404);
-    let body = resp.text().await?;
-    assert!(body.contains("chart not found"));
-    Ok(())
-}
diff --git a/benchmarks-website/server/tests/snapshots/chart_page_query.snap b/benchmarks-website/server/tests/snapshots/chart_page_query.snap
deleted file mode 100644
index 7c576b55234..00000000000
--- a/benchmarks-website/server/tests/snapshots/chart_page_query.snap
+++ /dev/null
@@ -1,6 +0,0 @@
----
-source: benchmarks-website/server/tests/chart_api.rs
-assertion_line: 52
-expression: body
----
-<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>tpch sf=1 Q1 [nvme] - Vortex Benchmarks</title><link rel="icon" type="image/png" media="(prefers-color-scheme: light)" href="/static/icon-light.png?v=bench-v3-ui-27"><link rel="icon" type="image/png" media="(prefers-color-scheme: dark)" href="/static/icon-dark.png?v=bench-v3-ui-27"><link rel="icon" type="image/png" href="/static/icon-dark.png?v=bench-v3-ui-27"><link rel="apple-touch-icon" href="/static/icon-dark.png?v=bench-v3-ui-27"><link rel="preconnect" href="https://fonts.googleapis.com"><link rel="preconnect" href="https://fonts.gstatic.com" crossorigin><link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Funnel+Display:wght@300;400;500;600;700;800&amp;display=swap"><link rel="stylesheet" href="https://unpkg.com/geist@1.3.0/dist/fonts/geist-sans/style.css"><link rel="stylesheet" href="https://unpkg.com/geist@1.3.0/dist/fonts/geist-mono/style.css"><script>(function(){try{var t=localStorage.getItem("bench-theme");if(t==="light"||t==="dark"){document.documentElement.dataset.theme=t;}}catch(e){}})();</script><link rel="stylesheet" href="/static/style.css?v=bench-v3-ui-27"></head><body><script id="bench-filter-state" type="application/json">{"engines":[],"formats":[]}</script><header class="sticky-header"><div class="header-content"><div class="header-left"><button class="control-btn nav-mobile-toggle" type="button" data-role="nav-mobile-toggle" aria-haspopup="true" aria-expanded="false" aria-controls="bench-nav-controls" aria-label="Toggle navigation menu"><svg class="btn-icon" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M4 6h16"></path><path d="M4 12h16"></path><path d="M4 18h16"></path></svg></button><a class="logo-link" href="/" aria-label="bench.vortex.dev home"><img class="site-logo logo-light" src="/Vortex_Black_NoBG.png?v=bench-v3-ui-27" alt="Vortex"><img class="site-logo logo-dark" src="/Vortex_White_NoBG.png?v=bench-v3-ui-27" alt="Vortex"></a><h1 class="site-title">Vortex Benchmarks</h1></div><div class="header-center"><div class="nav-controls" id="bench-nav-controls" data-role="nav-controls" aria-label="Benchmark group controls"><button class="control-btn" type="button" data-action="expand-all"><svg class="btn-icon" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m7 6 5 5 5-5"></path><path d="m7 13 5 5 5-5"></path></svg><span>Expand All</span></button><button class="control-btn" type="button" data-action="collapse-all"><svg class="btn-icon" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m17 18-5-5-5 5"></path><path d="m17 11-5-5-5 5"></path></svg><span>Collapse All</span></button><div class="filter-dropdown" data-role="global-filter-bar"><button class="control-btn filter-trigger" type="button" data-role="filter-trigger" aria-haspopup="true" aria-expanded="false"><svg class="btn-icon" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><polygon points="22 3 2 3 10 12.46 10 19 14 21 14 12.46 22 3"></polygon></svg><span>Filters</span></button><div class="filter-panel" data-role="filter-panel" hidden><div class="global-filter-row"><span class="global-filter-label">Engine</span><button class="filter-chip filter-chip--all" type="button" data-filter="engine" data-value="*" aria-pressed="false">all</button><button class="filter-chip filter-chip--active" type="button" data-filter="engine" data-value="datafusion" aria-pressed="true">datafusion</button><button class="filter-chip filter-chip--active" type="button" data-filter="engine" data-value="duckdb" aria-pressed="true">duckdb</button></div><div class="global-filter-row"><span class="global-filter-label">Format</span><button class="filter-chip filter-chip--all" type="button" data-filter="format" data-value="*" aria-pressed="false">all</button><button class="filter-chip filter-chip--active" type="button" data-filter="format" data-value="parquet" aria-pressed="true">parquet</button><button class="filter-chip filter-chip--active" type="button" data-filter="format" data-value="vortex-file-compressed" aria-pressed="true">vortex-file-compressed</button></div></div></div><a class="repo-link nav-controls-github" href="https://github.com/vortex-data/vortex" rel="noopener noreferrer" target="_blank"><svg class="github-logo" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" aria-hidden="true"><path d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z"></path></svg><span>GitHub</span></a></div></div><div class="header-right"><a class="repo-link repo-link-desktop" href="https://github.com/vortex-data/vortex" rel="noopener noreferrer" target="_blank"><svg class="github-logo" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" aria-hidden="true"><path d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z"></path></svg><span>GitHub</span></a><button class="control-btn theme-toggle" type="button" data-role="theme-toggle" data-next-theme="light" aria-label="Toggle color theme"><svg class="btn-icon theme-icon theme-icon-light" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="12" r="4"></circle><path d="M12 2v2"></path><path d="M12 20v2"></path><path d="m4.93 4.93 1.41 1.41"></path><path d="m17.66 17.66 1.41 1.41"></path><path d="M2 12h2"></path><path d="M20 12h2"></path><path d="m6.34 17.66-1.41 1.41"></path><path d="m19.07 4.93-1.41 1.41"></path></svg><svg class="btn-icon theme-icon theme-icon-dark" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M20.99 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 20.99 12.79z"></path></svg><span class="theme-toggle-label">Light</span></button></div></div></header><main><p class="chart-meta">unit: <code>ns</code> · 2 series · 3 commits<span class="chart-badge chart-badge--downsampled" data-role="downsample-badge" hidden></span></p><section class="chart-card" data-chart-index="0" data-chart-slug="qm.eyJrIjoiUXVlcnlNZWFzdXJlbWVudCIsImRhdGFzZXQiOiJ0cGNoIiwiZGF0YXNldF92YXJpYW50IjpudWxsLCJzY2FsZV9mYWN0b3IiOiIxIiwic3RvcmFnZSI6Im52bWUiLCJxdWVyeV9pZHgiOjF9" data-payload-window="100"><div class="toolbar toolbar--card" aria-label="Chart controls"><div class="toolbar-group" role="group" aria-label="Visible commits"><span class="toolbar-label">Show</span><input class="toolbar-slider" id="scope-slider-0" type="range" min="5" max="100" step="1" value="100" data-role="scope-slider" aria-label="Custom commit window"></div><div class="toolbar-group" role="group" aria-label="Y-axis scale"><span class="toolbar-label">Y</span><button class="toolbar-btn toolbar-btn--active" type="button" data-y="linear">linear</button><button class="toolbar-btn" type="button" data-y="log">log</button></div></div><div class="chart-tooltip-host"></div><div class="chart-wrap"><canvas data-chart-index="0"></canvas></div><div class="chart-range-strip" data-chart-index="0" data-role="range-strip" aria-label="Visible commit range" role="slider"><div class="chart-range-strip-track"><div class="chart-range-strip-window" data-role="range-window"><span class="chart-range-strip-handle chart-range-strip-handle--left" data-role="range-handle-left" aria-hidden="true"></span><span class="chart-range-strip-handle chart-range-strip-handle--right" data-role="range-handle-right" aria-hidden="true"></span></div></div></div><script id="chart-data-0" type="application/json">{"display_name":"tpch sf=1 Q1 [nvme]","unit_kind":"time_ns","history":{"total_commits":3,"start_index":0,"loaded_commits":3,"complete":true},"commits":[{"sha":"1111111111111111111111111111111111111111","timestamp":"2026-04-23 12:00:00+00","message":"first commit","url":"https://github.com/vortex-data/vortex/commit/1111111111111111111111111111111111111111"},{"sha":"2222222222222222222222222222222222222222","timestamp":"2026-04-24 12:00:00+00","message":"second commit","url":"https://github.com/vortex-data/vortex/commit/2222222222222222222222222222222222222222"},{"sha":"3333333333333333333333333333333333333333","timestamp":"2026-04-25 12:00:00+00","message":"third commit","url":"https://github.com/vortex-data/vortex/commit/3333333333333333333333333333333333333333"}],"series":{"datafusion:vortex-file-compressed":[1000000.0,1050000.0,1100000.0],"duckdb:parquet":[800000.0,850000.0,900000.0]},"series_meta":{"datafusion:vortex-file-compressed":{"engine":"datafusion","format":"vortex-file-compressed"},"duckdb:parquet":{"engine":"duckdb","format":"parquet"}}}</script></section><noscript><p class="no-script">JavaScript is required to render the chart.</p></noscript></main><footer class="site-footer"><span class="site-footer-label">build </span><a class="site-footer-sha" href="https://github.com/vortex-data/vortex/commit/<build-sha>" rel="noopener noreferrer" target="_blank"><code><build-sha></code></a></footer><script src="/static/chart.umd.js?v=bench-v3-ui-27" defer></script><script src="/static/chartjs-plugin-zoom.umd.min.js?v=bench-v3-ui-27" defer></script><script src="/static/chart-init.js?v=bench-v3-ui-27" defer></script></body></html>
diff --git a/benchmarks-website/server/tests/snapshots/group_page_query.snap b/benchmarks-website/server/tests/snapshots/group_page_query.snap
deleted file mode 100644
index a1716e15501..00000000000
--- a/benchmarks-website/server/tests/snapshots/group_page_query.snap
+++ /dev/null
@@ -1,6 +0,0 @@
----
-source: benchmarks-website/server/tests/group_api.rs
-assertion_line: 51
-expression: body
----
-<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>TPC-H (NVMe) (SF=1) - Vortex Benchmarks</title><link rel="icon" type="image/png" media="(prefers-color-scheme: light)" href="/static/icon-light.png?v=bench-v3-ui-27"><link rel="icon" type="image/png" media="(prefers-color-scheme: dark)" href="/static/icon-dark.png?v=bench-v3-ui-27"><link rel="icon" type="image/png" href="/static/icon-dark.png?v=bench-v3-ui-27"><link rel="apple-touch-icon" href="/static/icon-dark.png?v=bench-v3-ui-27"><link rel="preconnect" href="https://fonts.googleapis.com"><link rel="preconnect" href="https://fonts.gstatic.com" crossorigin><link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Funnel+Display:wght@300;400;500;600;700;800&amp;display=swap"><link rel="stylesheet" href="https://unpkg.com/geist@1.3.0/dist/fonts/geist-sans/style.css"><link rel="stylesheet" href="https://unpkg.com/geist@1.3.0/dist/fonts/geist-mono/style.css"><script>(function(){try{var t=localStorage.getItem("bench-theme");if(t==="light"||t==="dark"){document.documentElement.dataset.theme=t;}}catch(e){}})();</script><link rel="stylesheet" href="/static/style.css?v=bench-v3-ui-27"></head><body><script id="bench-filter-state" type="application/json">{"engines":[],"formats":[]}</script><header class="sticky-header"><div class="header-content"><div class="header-left"><button class="control-btn nav-mobile-toggle" type="button" data-role="nav-mobile-toggle" aria-haspopup="true" aria-expanded="false" aria-controls="bench-nav-controls" aria-label="Toggle navigation menu"><svg class="btn-icon" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M4 6h16"></path><path d="M4 12h16"></path><path d="M4 18h16"></path></svg></button><a class="logo-link" href="/" aria-label="bench.vortex.dev home"><img class="site-logo logo-light" src="/Vortex_Black_NoBG.png?v=bench-v3-ui-27" alt="Vortex"><img class="site-logo logo-dark" src="/Vortex_White_NoBG.png?v=bench-v3-ui-27" alt="Vortex"></a><h1 class="site-title">Vortex Benchmarks</h1></div><div class="header-center"><div class="nav-controls" id="bench-nav-controls" data-role="nav-controls" aria-label="Benchmark group controls"><button class="control-btn" type="button" data-action="expand-all"><svg class="btn-icon" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m7 6 5 5 5-5"></path><path d="m7 13 5 5 5-5"></path></svg><span>Expand All</span></button><button class="control-btn" type="button" data-action="collapse-all"><svg class="btn-icon" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m17 18-5-5-5 5"></path><path d="m17 11-5-5-5 5"></path></svg><span>Collapse All</span></button><div class="filter-dropdown" data-role="global-filter-bar"><button class="control-btn filter-trigger" type="button" data-role="filter-trigger" aria-haspopup="true" aria-expanded="false"><svg class="btn-icon" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><polygon points="22 3 2 3 10 12.46 10 19 14 21 14 12.46 22 3"></polygon></svg><span>Filters</span></button><div class="filter-panel" data-role="filter-panel" hidden><div class="global-filter-row"><span class="global-filter-label">Engine</span><button class="filter-chip filter-chip--all" type="button" data-filter="engine" data-value="*" aria-pressed="false">all</button><button class="filter-chip filter-chip--active" type="button" data-filter="engine" data-value="datafusion" aria-pressed="true">datafusion</button><button class="filter-chip filter-chip--active" type="button" data-filter="engine" data-value="duckdb" aria-pressed="true">duckdb</button></div><div class="global-filter-row"><span class="global-filter-label">Format</span><button class="filter-chip filter-chip--all" type="button" data-filter="format" data-value="*" aria-pressed="false">all</button><button class="filter-chip filter-chip--active" type="button" data-filter="format" data-value="parquet" aria-pressed="true">parquet</button><button class="filter-chip filter-chip--active" type="button" data-filter="format" data-value="vortex-file-compressed" aria-pressed="true">vortex-file-compressed</button></div></div></div><a class="repo-link nav-controls-github" href="https://github.com/vortex-data/vortex" rel="noopener noreferrer" target="_blank"><svg class="github-logo" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" aria-hidden="true"><path d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z"></path></svg><span>GitHub</span></a></div></div><div class="header-right"><a class="repo-link repo-link-desktop" href="https://github.com/vortex-data/vortex" rel="noopener noreferrer" target="_blank"><svg class="github-logo" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" aria-hidden="true"><path d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z"></path></svg><span>GitHub</span></a><button class="control-btn theme-toggle" type="button" data-role="theme-toggle" data-next-theme="light" aria-label="Toggle color theme"><svg class="btn-icon theme-icon theme-icon-light" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="12" r="4"></circle><path d="M12 2v2"></path><path d="M12 20v2"></path><path d="m4.93 4.93 1.41 1.41"></path><path d="m17.66 17.66 1.41 1.41"></path><path d="M2 12h2"></path><path d="M20 12h2"></path><path d="m6.34 17.66-1.41 1.41"></path><path d="m19.07 4.93-1.41 1.41"></path></svg><svg class="btn-icon theme-icon theme-icon-dark" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M20.99 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 20.99 12.79z"></path></svg><span class="theme-toggle-label">Light</span></button></div></div></header><main><section class="group-details" data-group-name="TPC-H (NVMe) (SF=1)" data-group-slug="qmg.eyJrIjoiUXVlcnlHcm91cCIsImRhdGFzZXQiOiJ0cGNoIiwiZGF0YXNldF92YXJpYW50IjpudWxsLCJzY2FsZV9mYWN0b3IiOiIxIiwic3RvcmFnZSI6Im52bWUifQ" data-artifact-generation="88da2a7ec8f3f538" data-group-shard-count="1" data-group-shard-prefix="/api/artifacts/88da2a7ec8f3f538/groups/qmg.eyJrIjoiUXVlcnlHcm91cCIsImRhdGFzZXQiOiJ0cGNoIiwiZGF0YXNldF92YXJpYW50IjpudWxsLCJzY2FsZV9mYWN0b3IiOiIxIiwic3RvcmFnZSI6Im52bWUifQ/shards/"><details class="group-disclosure" open><summary class="group-summary"><span class="group-summary-row"><span class="group-name">TPC-H (NVMe) (SF=1)</span><span class="group-info-icon" tabindex="0" role="note" aria-label="TPC-H benchmark queries on local NVMe storage at SF=1 (~1GB of data)" data-tooltip="TPC-H benchmark queries on local NVMe storage at SF=1 (~1GB of data)">ⓘ</span><span class="group-count">2 charts</span></span></summary></details><section class="benchmark-scores-summary" aria-label="Performance Summary"><h3 class="scores-title">Performance Summary</h3><div class="scores-list"><div class="score-item"><span class="score-rank">#1</span><span class="score-series" title="datafusion:vortex-file-compressed">datafusion:vortex-file-compressed</span><span class="score-metrics"><span class="score-value">1.11x</span><span class="score-runtime">1.80 ms</span></span></div><div class="score-item"><span class="score-rank">#2</span><span class="score-series" title="duckdb:parquet">duckdb:parquet</span><span class="score-metrics"><span class="score-value">1.60x</span><span class="score-runtime">900.00 us</span></span></div></div><div class="scores-explanation">Geomean of query time ratio to fastest (lower is better)</div></section><section class="group-toolbar" data-role="group-toolbar"><div class="toolbar-group group-toolbar-y" role="group" aria-label="Group Y-axis scale"><span class="toolbar-label">Y</span><button class="toolbar-btn toolbar-btn--active" type="button" data-group-y="linear">linear</button><button class="toolbar-btn" type="button" data-group-y="log">log</button></div><div class="group-filter-dropdown" data-role="group-filter-dropdown"><button class="control-btn filter-trigger group-filter-trigger" type="button" data-role="group-filter-trigger" aria-haspopup="true" aria-expanded="false"><svg class="btn-icon" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><polygon points="22 3 2 3 10 12.46 10 19 14 21 14 12.46 22 3"></polygon></svg><span>Filter series</span></button><div class="filter-panel group-filter-panel" data-role="group-filter-panel" hidden><div class="global-filter-row group-macro-row"><span class="global-filter-label">Engine</span><button class="filter-chip filter-chip--all" type="button" data-group-filter="engine" data-value="*" aria-pressed="false">all</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="engine" data-value="datafusion" aria-pressed="true">datafusion</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="engine" data-value="duckdb" aria-pressed="true">duckdb</button></div><div class="global-filter-row group-macro-row"><span class="global-filter-label">Format</span><button class="filter-chip filter-chip--all" type="button" data-group-filter="format" data-value="*" aria-pressed="false">all</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="format" data-value="parquet" aria-pressed="true">parquet</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="format" data-value="vortex-file-compressed" aria-pressed="true">vortex-file-compressed</button></div><div class="global-filter-row group-series-row"><span class="global-filter-label">Series</span><button class="filter-chip filter-chip--all" type="button" data-group-filter="series" data-value="*" aria-pressed="false">all</button><div class="group-series-chips" data-role="group-series-chips"></div></div></div></div><button class="group-toolbar-reset" type="button" data-role="group-toolbar-reset">Reset group</button></section><div class="chart-grid"><section class="chart-card" data-chart-index="0" data-chart-slug="qm.eyJrIjoiUXVlcnlNZWFzdXJlbWVudCIsImRhdGFzZXQiOiJ0cGNoIiwiZGF0YXNldF92YXJpYW50IjpudWxsLCJzY2FsZV9mYWN0b3IiOiIxIiwic3RvcmFnZSI6Im52bWUiLCJxdWVyeV9pZHgiOjF9"><h3 class="chart-card-title"><a href="/chart/qm.eyJrIjoiUXVlcnlNZWFzdXJlbWVudCIsImRhdGFzZXQiOiJ0cGNoIiwiZGF0YXNldF92YXJpYW50IjpudWxsLCJzY2FsZV9mYWN0b3IiOiIxIiwic3RvcmFnZSI6Im52bWUiLCJxdWVyeV9pZHgiOjF9">Q1</a><span class="chart-badge chart-badge--downsampled" data-role="downsample-badge" hidden></span></h3><div class="toolbar toolbar--card" aria-label="Chart controls"><div class="toolbar-group" role="group" aria-label="Visible commits"><span class="toolbar-label">Show</span><input class="toolbar-slider" id="scope-slider-0" type="range" min="5" max="100" step="1" value="100" data-role="scope-slider" aria-label="Custom commit window"></div><div class="toolbar-group" role="group" aria-label="Y-axis scale"><span class="toolbar-label">Y</span><button class="toolbar-btn toolbar-btn--active" type="button" data-y="linear">linear</button><button class="toolbar-btn" type="button" data-y="log">log</button></div></div><div class="chart-tooltip-host"></div><div class="chart-wrap"><canvas data-chart-index="0"></canvas></div><div class="chart-range-strip" data-chart-index="0" data-role="range-strip" aria-label="Visible commit range" role="slider"><div class="chart-range-strip-track"><div class="chart-range-strip-window" data-role="range-window"><span class="chart-range-strip-handle chart-range-strip-handle--left" data-role="range-handle-left" aria-hidden="true"></span><span class="chart-range-strip-handle chart-range-strip-handle--right" data-role="range-handle-right" aria-hidden="true"></span></div></div></div></section><section class="chart-card" data-chart-index="1" data-chart-slug="qm.eyJrIjoiUXVlcnlNZWFzdXJlbWVudCIsImRhdGFzZXQiOiJ0cGNoIiwiZGF0YXNldF92YXJpYW50IjpudWxsLCJzY2FsZV9mYWN0b3IiOiIxIiwic3RvcmFnZSI6Im52bWUiLCJxdWVyeV9pZHgiOjJ9"><h3 class="chart-card-title"><a href="/chart/qm.eyJrIjoiUXVlcnlNZWFzdXJlbWVudCIsImRhdGFzZXQiOiJ0cGNoIiwiZGF0YXNldF92YXJpYW50IjpudWxsLCJzY2FsZV9mYWN0b3IiOiIxIiwic3RvcmFnZSI6Im52bWUiLCJxdWVyeV9pZHgiOjJ9">Q2</a><span class="chart-badge chart-badge--downsampled" data-role="downsample-badge" hidden></span></h3><div class="toolbar toolbar--card" aria-label="Chart controls"><div class="toolbar-group" role="group" aria-label="Visible commits"><span class="toolbar-label">Show</span><input class="toolbar-slider" id="scope-slider-1" type="range" min="5" max="100" step="1" value="100" data-role="scope-slider" aria-label="Custom commit window"></div><div class="toolbar-group" role="group" aria-label="Y-axis scale"><span class="toolbar-label">Y</span><button class="toolbar-btn toolbar-btn--active" type="button" data-y="linear">linear</button><button class="toolbar-btn" type="button" data-y="log">log</button></div></div><div class="chart-tooltip-host"></div><div class="chart-wrap"><canvas data-chart-index="1"></canvas></div><div class="chart-range-strip" data-chart-index="1" data-role="range-strip" aria-label="Visible commit range" role="slider"><div class="chart-range-strip-track"><div class="chart-range-strip-window" data-role="range-window"><span class="chart-range-strip-handle chart-range-strip-handle--left" data-role="range-handle-left" aria-hidden="true"></span><span class="chart-range-strip-handle chart-range-strip-handle--right" data-role="range-handle-right" aria-hidden="true"></span></div></div></div></section></div></section><noscript><p class="no-script">JavaScript is required to render the charts.</p></noscript></main><footer class="site-footer"><span class="site-footer-label">build </span><a class="site-footer-sha" href="https://github.com/vortex-data/vortex/commit/<build-sha>" rel="noopener noreferrer" target="_blank"><code><build-sha></code></a></footer><script src="/static/chart.umd.js?v=bench-v3-ui-27" defer></script><script src="/static/chartjs-plugin-zoom.umd.min.js?v=bench-v3-ui-27" defer></script><script src="/static/chart-init.js?v=bench-v3-ui-27" defer></script></body></html>
diff --git a/benchmarks-website/server/tests/snapshots/landing_page.snap b/benchmarks-website/server/tests/snapshots/landing_page.snap
deleted file mode 100644
index 8337ed6dc05..00000000000
--- a/benchmarks-website/server/tests/snapshots/landing_page.snap
+++ /dev/null
@@ -1,6 +0,0 @@
----
-source: benchmarks-website/server/tests/landing.rs
-assertion_line: 102
-expression: body
----
-<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>Vortex Benchmarks</title><link rel="icon" type="image/png" media="(prefers-color-scheme: light)" href="/static/icon-light.png?v=bench-v3-ui-27"><link rel="icon" type="image/png" media="(prefers-color-scheme: dark)" href="/static/icon-dark.png?v=bench-v3-ui-27"><link rel="icon" type="image/png" href="/static/icon-dark.png?v=bench-v3-ui-27"><link rel="apple-touch-icon" href="/static/icon-dark.png?v=bench-v3-ui-27"><link rel="preconnect" href="https://fonts.googleapis.com"><link rel="preconnect" href="https://fonts.gstatic.com" crossorigin><link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Funnel+Display:wght@300;400;500;600;700;800&amp;display=swap"><link rel="stylesheet" href="https://unpkg.com/geist@1.3.0/dist/fonts/geist-sans/style.css"><link rel="stylesheet" href="https://unpkg.com/geist@1.3.0/dist/fonts/geist-mono/style.css"><script>(function(){try{var t=localStorage.getItem("bench-theme");if(t==="light"||t==="dark"){document.documentElement.dataset.theme=t;}}catch(e){}})();</script><link rel="stylesheet" href="/static/style.css?v=bench-v3-ui-27"></head><body><script id="bench-filter-state" type="application/json">{"engines":[],"formats":[]}</script><header class="sticky-header"><div class="header-content"><div class="header-left"><button class="control-btn nav-mobile-toggle" type="button" data-role="nav-mobile-toggle" aria-haspopup="true" aria-expanded="false" aria-controls="bench-nav-controls" aria-label="Toggle navigation menu"><svg class="btn-icon" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M4 6h16"></path><path d="M4 12h16"></path><path d="M4 18h16"></path></svg></button><a class="logo-link" href="/" aria-label="bench.vortex.dev home"><img class="site-logo logo-light" src="/Vortex_Black_NoBG.png?v=bench-v3-ui-27" alt="Vortex"><img class="site-logo logo-dark" src="/Vortex_White_NoBG.png?v=bench-v3-ui-27" alt="Vortex"></a><h1 class="site-title">Vortex Benchmarks</h1></div><div class="header-center"><div class="nav-controls" id="bench-nav-controls" data-role="nav-controls" aria-label="Benchmark group controls"><button class="control-btn" type="button" data-action="expand-all"><svg class="btn-icon" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m7 6 5 5 5-5"></path><path d="m7 13 5 5 5-5"></path></svg><span>Expand All</span></button><button class="control-btn" type="button" data-action="collapse-all"><svg class="btn-icon" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m17 18-5-5-5 5"></path><path d="m17 11-5-5-5 5"></path></svg><span>Collapse All</span></button><div class="filter-dropdown" data-role="global-filter-bar"><button class="control-btn filter-trigger" type="button" data-role="filter-trigger" aria-haspopup="true" aria-expanded="false"><svg class="btn-icon" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><polygon points="22 3 2 3 10 12.46 10 19 14 21 14 12.46 22 3"></polygon></svg><span>Filters</span></button><div class="filter-panel" data-role="filter-panel" hidden><div class="global-filter-row"><span class="global-filter-label">Engine</span><button class="filter-chip filter-chip--all" type="button" data-filter="engine" data-value="*" aria-pressed="false">all</button><button class="filter-chip filter-chip--active" type="button" data-filter="engine" data-value="datafusion" aria-pressed="true">datafusion</button><button class="filter-chip filter-chip--active" type="button" data-filter="engine" data-value="duckdb" aria-pressed="true">duckdb</button></div><div class="global-filter-row"><span class="global-filter-label">Format</span><button class="filter-chip filter-chip--all" type="button" data-filter="format" data-value="*" aria-pressed="false">all</button><button class="filter-chip filter-chip--active" type="button" data-filter="format" data-value="parquet" aria-pressed="true">parquet</button><button class="filter-chip filter-chip--active" type="button" data-filter="format" data-value="vortex-file-compressed" aria-pressed="true">vortex-file-compressed</button></div></div></div><a class="repo-link nav-controls-github" href="https://github.com/vortex-data/vortex" rel="noopener noreferrer" target="_blank"><svg class="github-logo" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" aria-hidden="true"><path d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z"></path></svg><span>GitHub</span></a></div></div><div class="header-right"><a class="repo-link repo-link-desktop" href="https://github.com/vortex-data/vortex" rel="noopener noreferrer" target="_blank"><svg class="github-logo" viewBox="0 0 16 16" width="16" height="16" fill="currentColor" aria-hidden="true"><path d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z"></path></svg><span>GitHub</span></a><button class="control-btn theme-toggle" type="button" data-role="theme-toggle" data-next-theme="light" aria-label="Toggle color theme"><svg class="btn-icon theme-icon theme-icon-light" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="12" r="4"></circle><path d="M12 2v2"></path><path d="M12 20v2"></path><path d="m4.93 4.93 1.41 1.41"></path><path d="m17.66 17.66 1.41 1.41"></path><path d="M2 12h2"></path><path d="M20 12h2"></path><path d="m6.34 17.66-1.41 1.41"></path><path d="m19.07 4.93-1.41 1.41"></path></svg><svg class="btn-icon theme-icon theme-icon-dark" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M20.99 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 20.99 12.79z"></path></svg><span class="theme-toggle-label">Light</span></button></div></div></header><main><section class="group-details" data-group-name="Random Access" data-group-slug="rag.eyJrIjoiUmFuZG9tQWNjZXNzR3JvdXAifQ" data-artifact-generation="88da2a7ec8f3f538" data-group-shard-count="1" data-group-shard-prefix="/api/artifacts/88da2a7ec8f3f538/groups/rag.eyJrIjoiUmFuZG9tQWNjZXNzR3JvdXAifQ/shards/"><details class="group-disclosure"><summary class="group-summary"><span class="group-summary-row"><span class="group-name">Random Access</span><span class="group-info-icon" tabindex="0" role="note" aria-label="Tests performance of selecting arbitrary row indices from a file on NVMe storage" data-tooltip="Tests performance of selecting arbitrary row indices from a file on NVMe storage">ⓘ</span><span class="group-count">1 chart</span></span></summary></details><section class="benchmark-scores-summary" aria-label="Random Access Performance"><h3 class="scores-title">Random Access Performance</h3><div class="scores-list"><div class="score-item"><span class="score-rank">#1</span><span class="score-series" title="vortex-file-compressed">vortex-file-compressed</span><span class="score-metrics"><span class="score-value">100.50 us</span><span class="score-runtime">1.00x</span></span></div><div class="score-item"><span class="score-rank">#2</span><span class="score-series" title="parquet">parquet</span><span class="score-metrics"><span class="score-value">201.00 us</span><span class="score-runtime">2.00x</span></span></div></div><div class="scores-explanation">Random access time | Ratio to fastest (lower is better)</div></section><section class="group-toolbar" data-role="group-toolbar"><div class="toolbar-group group-toolbar-y" role="group" aria-label="Group Y-axis scale"><span class="toolbar-label">Y</span><button class="toolbar-btn toolbar-btn--active" type="button" data-group-y="linear">linear</button><button class="toolbar-btn" type="button" data-group-y="log">log</button></div><div class="group-filter-dropdown" data-role="group-filter-dropdown"><button class="control-btn filter-trigger group-filter-trigger" type="button" data-role="group-filter-trigger" aria-haspopup="true" aria-expanded="false"><svg class="btn-icon" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><polygon points="22 3 2 3 10 12.46 10 19 14 21 14 12.46 22 3"></polygon></svg><span>Filter series</span></button><div class="filter-panel group-filter-panel" data-role="group-filter-panel" hidden><div class="global-filter-row group-macro-row"><span class="global-filter-label">Engine</span><button class="filter-chip filter-chip--all" type="button" data-group-filter="engine" data-value="*" aria-pressed="false">all</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="engine" data-value="datafusion" aria-pressed="true">datafusion</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="engine" data-value="duckdb" aria-pressed="true">duckdb</button></div><div class="global-filter-row group-macro-row"><span class="global-filter-label">Format</span><button class="filter-chip filter-chip--all" type="button" data-group-filter="format" data-value="*" aria-pressed="false">all</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="format" data-value="parquet" aria-pressed="true">parquet</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="format" data-value="vortex-file-compressed" aria-pressed="true">vortex-file-compressed</button></div><div class="global-filter-row group-series-row"><span class="global-filter-label">Series</span><button class="filter-chip filter-chip--all" type="button" data-group-filter="series" data-value="*" aria-pressed="false">all</button><div class="group-series-chips" data-role="group-series-chips"></div></div></div></div><button class="group-toolbar-reset" type="button" data-role="group-toolbar-reset">Reset group</button></section><div class="chart-grid"><section class="chart-card" data-chart-index="0" data-chart-slug="rat.eyJrIjoiUmFuZG9tQWNjZXNzIiwiZGF0YXNldCI6InRheGkifQ"><h3 class="chart-card-title"><a href="/chart/rat.eyJrIjoiUmFuZG9tQWNjZXNzIiwiZGF0YXNldCI6InRheGkifQ">taxi</a><span class="chart-badge chart-badge--downsampled" data-role="downsample-badge" hidden></span></h3><div class="toolbar toolbar--card" aria-label="Chart controls"><div class="toolbar-group" role="group" aria-label="Visible commits"><span class="toolbar-label">Show</span><input class="toolbar-slider" id="scope-slider-0" type="range" min="5" max="100" step="1" value="100" data-role="scope-slider" aria-label="Custom commit window"></div><div class="toolbar-group" role="group" aria-label="Y-axis scale"><span class="toolbar-label">Y</span><button class="toolbar-btn toolbar-btn--active" type="button" data-y="linear">linear</button><button class="toolbar-btn" type="button" data-y="log">log</button></div></div><div class="chart-tooltip-host"></div><div class="chart-wrap"><canvas data-chart-index="0"></canvas></div><div class="chart-range-strip" data-chart-index="0" data-role="range-strip" aria-label="Visible commit range" role="slider"><div class="chart-range-strip-track"><div class="chart-range-strip-window" data-role="range-window"><span class="chart-range-strip-handle chart-range-strip-handle--left" data-role="range-handle-left" aria-hidden="true"></span><span class="chart-range-strip-handle chart-range-strip-handle--right" data-role="range-handle-right" aria-hidden="true"></span></div></div></div></section></div></section><section class="group-details" data-group-name="Compression" data-group-slug="ctg.eyJrIjoiQ29tcHJlc3Npb25UaW1lR3JvdXAifQ" data-artifact-generation="88da2a7ec8f3f538" data-group-shard-count="1" data-group-shard-prefix="/api/artifacts/88da2a7ec8f3f538/groups/ctg.eyJrIjoiQ29tcHJlc3Npb25UaW1lR3JvdXAifQ/shards/"><details class="group-disclosure"><summary class="group-summary"><span class="group-summary-row"><span class="group-name">Compression</span><span class="group-info-icon" tabindex="0" role="note" aria-label="Measures encoding and decoding throughput (MB/s) for Vortex files and Parquet files (with zstd page compression)" data-tooltip="Measures encoding and decoding throughput (MB/s) for Vortex files and Parquet files (with zstd page compression)">ⓘ</span><span class="group-count">1 chart</span></span></summary></details><section class="benchmark-scores-summary" aria-label="Compression Throughput vs Parquet"><h3 class="scores-title">Compression Throughput vs Parquet</h3><div class="scores-list"><div class="score-item"><span class="score-rank">⚡</span><span class="score-series">Write Speed (Compression)</span><span class="score-metrics"><span class="score-value">2.00x</span></span></div><div class="score-item"><span class="score-rank">📤</span><span class="score-series">Scan Speed (Decompression)</span><span class="score-metrics"><span class="score-value">2.00x</span></span></div></div><div class="scores-explanation">Inverse geomean of Vortex/Parquet ratios (higher is better)</div></section><section class="group-toolbar" data-role="group-toolbar"><div class="toolbar-group group-toolbar-y" role="group" aria-label="Group Y-axis scale"><span class="toolbar-label">Y</span><button class="toolbar-btn toolbar-btn--active" type="button" data-group-y="linear">linear</button><button class="toolbar-btn" type="button" data-group-y="log">log</button></div><div class="group-filter-dropdown" data-role="group-filter-dropdown"><button class="control-btn filter-trigger group-filter-trigger" type="button" data-role="group-filter-trigger" aria-haspopup="true" aria-expanded="false"><svg class="btn-icon" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><polygon points="22 3 2 3 10 12.46 10 19 14 21 14 12.46 22 3"></polygon></svg><span>Filter series</span></button><div class="filter-panel group-filter-panel" data-role="group-filter-panel" hidden><div class="global-filter-row group-macro-row"><span class="global-filter-label">Engine</span><button class="filter-chip filter-chip--all" type="button" data-group-filter="engine" data-value="*" aria-pressed="false">all</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="engine" data-value="datafusion" aria-pressed="true">datafusion</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="engine" data-value="duckdb" aria-pressed="true">duckdb</button></div><div class="global-filter-row group-macro-row"><span class="global-filter-label">Format</span><button class="filter-chip filter-chip--all" type="button" data-group-filter="format" data-value="*" aria-pressed="false">all</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="format" data-value="parquet" aria-pressed="true">parquet</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="format" data-value="vortex-file-compressed" aria-pressed="true">vortex-file-compressed</button></div><div class="global-filter-row group-series-row"><span class="global-filter-label">Series</span><button class="filter-chip filter-chip--all" type="button" data-group-filter="series" data-value="*" aria-pressed="false">all</button><div class="group-series-chips" data-role="group-series-chips"></div></div></div></div><button class="group-toolbar-reset" type="button" data-role="group-toolbar-reset">Reset group</button></section><div class="chart-grid"><section class="chart-card" data-chart-index="1" data-chart-slug="ct.eyJrIjoiQ29tcHJlc3Npb25UaW1lIiwiZGF0YXNldCI6InRwY2gtbGluZWl0ZW0iLCJkYXRhc2V0X3ZhcmlhbnQiOm51bGx9"><h3 class="chart-card-title"><a href="/chart/ct.eyJrIjoiQ29tcHJlc3Npb25UaW1lIiwiZGF0YXNldCI6InRwY2gtbGluZWl0ZW0iLCJkYXRhc2V0X3ZhcmlhbnQiOm51bGx9">tpch-lineitem</a><span class="chart-badge chart-badge--downsampled" data-role="downsample-badge" hidden></span></h3><div class="toolbar toolbar--card" aria-label="Chart controls"><div class="toolbar-group" role="group" aria-label="Visible commits"><span class="toolbar-label">Show</span><input class="toolbar-slider" id="scope-slider-1" type="range" min="5" max="100" step="1" value="100" data-role="scope-slider" aria-label="Custom commit window"></div><div class="toolbar-group" role="group" aria-label="Y-axis scale"><span class="toolbar-label">Y</span><button class="toolbar-btn toolbar-btn--active" type="button" data-y="linear">linear</button><button class="toolbar-btn" type="button" data-y="log">log</button></div></div><div class="chart-tooltip-host"></div><div class="chart-wrap"><canvas data-chart-index="1"></canvas></div><div class="chart-range-strip" data-chart-index="1" data-role="range-strip" aria-label="Visible commit range" role="slider"><div class="chart-range-strip-track"><div class="chart-range-strip-window" data-role="range-window"><span class="chart-range-strip-handle chart-range-strip-handle--left" data-role="range-handle-left" aria-hidden="true"></span><span class="chart-range-strip-handle chart-range-strip-handle--right" data-role="range-handle-right" aria-hidden="true"></span></div></div></div></section></div></section><section class="group-details" data-group-name="Compression Size" data-group-slug="csg.eyJrIjoiQ29tcHJlc3Npb25TaXplR3JvdXAifQ" data-artifact-generation="88da2a7ec8f3f538" data-group-shard-count="1" data-group-shard-prefix="/api/artifacts/88da2a7ec8f3f538/groups/csg.eyJrIjoiQ29tcHJlc3Npb25TaXplR3JvdXAifQ/shards/"><details class="group-disclosure"><summary class="group-summary"><span class="group-summary-row"><span class="group-name">Compression Size</span><span class="group-info-icon" tabindex="0" role="note" aria-label="Compares compressed file sizes and compression ratios across different encoding strategies" data-tooltip="Compares compressed file sizes and compression ratios across different encoding strategies">ⓘ</span><span class="group-count">1 chart</span></span></summary></details><section class="benchmark-scores-summary" aria-label="Compression Size Summary"><h3 class="scores-title">Compression Size Summary</h3><div class="scores-list"><div class="score-item"><span class="score-rank">⬇️</span><span class="score-series">Min Size Ratio</span><span class="score-metrics"><span class="score-value">0.50x</span></span></div><div class="score-item"><span class="score-rank">📊</span><span class="score-series">Mean Size Ratio</span><span class="score-metrics"><span class="score-value">0.50x</span></span></div><div class="score-item"><span class="score-rank">⬆️</span><span class="score-series">Max Size Ratio</span><span class="score-metrics"><span class="score-value">0.50x</span></span></div></div><div class="scores-explanation">Geomean of Vortex/Parquet size ratios (lower is better)</div></section><section class="group-toolbar" data-role="group-toolbar"><div class="toolbar-group group-toolbar-y" role="group" aria-label="Group Y-axis scale"><span class="toolbar-label">Y</span><button class="toolbar-btn toolbar-btn--active" type="button" data-group-y="linear">linear</button><button class="toolbar-btn" type="button" data-group-y="log">log</button></div><div class="group-filter-dropdown" data-role="group-filter-dropdown"><button class="control-btn filter-trigger group-filter-trigger" type="button" data-role="group-filter-trigger" aria-haspopup="true" aria-expanded="false"><svg class="btn-icon" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><polygon points="22 3 2 3 10 12.46 10 19 14 21 14 12.46 22 3"></polygon></svg><span>Filter series</span></button><div class="filter-panel group-filter-panel" data-role="group-filter-panel" hidden><div class="global-filter-row group-macro-row"><span class="global-filter-label">Engine</span><button class="filter-chip filter-chip--all" type="button" data-group-filter="engine" data-value="*" aria-pressed="false">all</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="engine" data-value="datafusion" aria-pressed="true">datafusion</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="engine" data-value="duckdb" aria-pressed="true">duckdb</button></div><div class="global-filter-row group-macro-row"><span class="global-filter-label">Format</span><button class="filter-chip filter-chip--all" type="button" data-group-filter="format" data-value="*" aria-pressed="false">all</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="format" data-value="parquet" aria-pressed="true">parquet</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="format" data-value="vortex-file-compressed" aria-pressed="true">vortex-file-compressed</button></div><div class="global-filter-row group-series-row"><span class="global-filter-label">Series</span><button class="filter-chip filter-chip--all" type="button" data-group-filter="series" data-value="*" aria-pressed="false">all</button><div class="group-series-chips" data-role="group-series-chips"></div></div></div></div><button class="group-toolbar-reset" type="button" data-role="group-toolbar-reset">Reset group</button></section><div class="chart-grid"><section class="chart-card" data-chart-index="2" data-chart-slug="cs.eyJrIjoiQ29tcHJlc3Npb25TaXplIiwiZGF0YXNldCI6InRwY2gtbGluZWl0ZW0iLCJkYXRhc2V0X3ZhcmlhbnQiOm51bGx9"><h3 class="chart-card-title"><a href="/chart/cs.eyJrIjoiQ29tcHJlc3Npb25TaXplIiwiZGF0YXNldCI6InRwY2gtbGluZWl0ZW0iLCJkYXRhc2V0X3ZhcmlhbnQiOm51bGx9">tpch-lineitem</a><span class="chart-badge chart-badge--downsampled" data-role="downsample-badge" hidden></span></h3><div class="toolbar toolbar--card" aria-label="Chart controls"><div class="toolbar-group" role="group" aria-label="Visible commits"><span class="toolbar-label">Show</span><input class="toolbar-slider" id="scope-slider-2" type="range" min="5" max="100" step="1" value="100" data-role="scope-slider" aria-label="Custom commit window"></div><div class="toolbar-group" role="group" aria-label="Y-axis scale"><span class="toolbar-label">Y</span><button class="toolbar-btn toolbar-btn--active" type="button" data-y="linear">linear</button><button class="toolbar-btn" type="button" data-y="log">log</button></div></div><div class="chart-tooltip-host"></div><div class="chart-wrap"><canvas data-chart-index="2"></canvas></div><div class="chart-range-strip" data-chart-index="2" data-role="range-strip" aria-label="Visible commit range" role="slider"><div class="chart-range-strip-track"><div class="chart-range-strip-window" data-role="range-window"><span class="chart-range-strip-handle chart-range-strip-handle--left" data-role="range-handle-left" aria-hidden="true"></span><span class="chart-range-strip-handle chart-range-strip-handle--right" data-role="range-handle-right" aria-hidden="true"></span></div></div></div></section></div></section><section class="group-details" data-group-name="TPC-H (NVMe) (SF=1)" data-group-slug="qmg.eyJrIjoiUXVlcnlHcm91cCIsImRhdGFzZXQiOiJ0cGNoIiwiZGF0YXNldF92YXJpYW50IjpudWxsLCJzY2FsZV9mYWN0b3IiOiIxIiwic3RvcmFnZSI6Im52bWUifQ" data-artifact-generation="88da2a7ec8f3f538" data-group-shard-count="1" data-group-shard-prefix="/api/artifacts/88da2a7ec8f3f538/groups/qmg.eyJrIjoiUXVlcnlHcm91cCIsImRhdGFzZXQiOiJ0cGNoIiwiZGF0YXNldF92YXJpYW50IjpudWxsLCJzY2FsZV9mYWN0b3IiOiIxIiwic3RvcmFnZSI6Im52bWUifQ/shards/"><details class="group-disclosure"><summary class="group-summary"><span class="group-summary-row"><span class="group-name">TPC-H (NVMe) (SF=1)</span><span class="group-info-icon" tabindex="0" role="note" aria-label="TPC-H benchmark queries on local NVMe storage at SF=1 (~1GB of data)" data-tooltip="TPC-H benchmark queries on local NVMe storage at SF=1 (~1GB of data)">ⓘ</span><span class="group-count">2 charts</span></span></summary></details><section class="benchmark-scores-summary" aria-label="Performance Summary"><h3 class="scores-title">Performance Summary</h3><div class="scores-list"><div class="score-item"><span class="score-rank">#1</span><span class="score-series" title="datafusion:vortex-file-compressed">datafusion:vortex-file-compressed</span><span class="score-metrics"><span class="score-value">1.11x</span><span class="score-runtime">1.80 ms</span></span></div><div class="score-item"><span class="score-rank">#2</span><span class="score-series" title="duckdb:parquet">duckdb:parquet</span><span class="score-metrics"><span class="score-value">1.60x</span><span class="score-runtime">900.00 us</span></span></div></div><div class="scores-explanation">Geomean of query time ratio to fastest (lower is better)</div></section><section class="group-toolbar" data-role="group-toolbar"><div class="toolbar-group group-toolbar-y" role="group" aria-label="Group Y-axis scale"><span class="toolbar-label">Y</span><button class="toolbar-btn toolbar-btn--active" type="button" data-group-y="linear">linear</button><button class="toolbar-btn" type="button" data-group-y="log">log</button></div><div class="group-filter-dropdown" data-role="group-filter-dropdown"><button class="control-btn filter-trigger group-filter-trigger" type="button" data-role="group-filter-trigger" aria-haspopup="true" aria-expanded="false"><svg class="btn-icon" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><polygon points="22 3 2 3 10 12.46 10 19 14 21 14 12.46 22 3"></polygon></svg><span>Filter series</span></button><div class="filter-panel group-filter-panel" data-role="group-filter-panel" hidden><div class="global-filter-row group-macro-row"><span class="global-filter-label">Engine</span><button class="filter-chip filter-chip--all" type="button" data-group-filter="engine" data-value="*" aria-pressed="false">all</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="engine" data-value="datafusion" aria-pressed="true">datafusion</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="engine" data-value="duckdb" aria-pressed="true">duckdb</button></div><div class="global-filter-row group-macro-row"><span class="global-filter-label">Format</span><button class="filter-chip filter-chip--all" type="button" data-group-filter="format" data-value="*" aria-pressed="false">all</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="format" data-value="parquet" aria-pressed="true">parquet</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="format" data-value="vortex-file-compressed" aria-pressed="true">vortex-file-compressed</button></div><div class="global-filter-row group-series-row"><span class="global-filter-label">Series</span><button class="filter-chip filter-chip--all" type="button" data-group-filter="series" data-value="*" aria-pressed="false">all</button><div class="group-series-chips" data-role="group-series-chips"></div></div></div></div><button class="group-toolbar-reset" type="button" data-role="group-toolbar-reset">Reset group</button></section><div class="chart-grid"><section class="chart-card" data-chart-index="3" data-chart-slug="qm.eyJrIjoiUXVlcnlNZWFzdXJlbWVudCIsImRhdGFzZXQiOiJ0cGNoIiwiZGF0YXNldF92YXJpYW50IjpudWxsLCJzY2FsZV9mYWN0b3IiOiIxIiwic3RvcmFnZSI6Im52bWUiLCJxdWVyeV9pZHgiOjF9"><h3 class="chart-card-title"><a href="/chart/qm.eyJrIjoiUXVlcnlNZWFzdXJlbWVudCIsImRhdGFzZXQiOiJ0cGNoIiwiZGF0YXNldF92YXJpYW50IjpudWxsLCJzY2FsZV9mYWN0b3IiOiIxIiwic3RvcmFnZSI6Im52bWUiLCJxdWVyeV9pZHgiOjF9">Q1</a><span class="chart-badge chart-badge--downsampled" data-role="downsample-badge" hidden></span></h3><div class="toolbar toolbar--card" aria-label="Chart controls"><div class="toolbar-group" role="group" aria-label="Visible commits"><span class="toolbar-label">Show</span><input class="toolbar-slider" id="scope-slider-3" type="range" min="5" max="100" step="1" value="100" data-role="scope-slider" aria-label="Custom commit window"></div><div class="toolbar-group" role="group" aria-label="Y-axis scale"><span class="toolbar-label">Y</span><button class="toolbar-btn toolbar-btn--active" type="button" data-y="linear">linear</button><button class="toolbar-btn" type="button" data-y="log">log</button></div></div><div class="chart-tooltip-host"></div><div class="chart-wrap"><canvas data-chart-index="3"></canvas></div><div class="chart-range-strip" data-chart-index="3" data-role="range-strip" aria-label="Visible commit range" role="slider"><div class="chart-range-strip-track"><div class="chart-range-strip-window" data-role="range-window"><span class="chart-range-strip-handle chart-range-strip-handle--left" data-role="range-handle-left" aria-hidden="true"></span><span class="chart-range-strip-handle chart-range-strip-handle--right" data-role="range-handle-right" aria-hidden="true"></span></div></div></div></section><section class="chart-card" data-chart-index="4" data-chart-slug="qm.eyJrIjoiUXVlcnlNZWFzdXJlbWVudCIsImRhdGFzZXQiOiJ0cGNoIiwiZGF0YXNldF92YXJpYW50IjpudWxsLCJzY2FsZV9mYWN0b3IiOiIxIiwic3RvcmFnZSI6Im52bWUiLCJxdWVyeV9pZHgiOjJ9"><h3 class="chart-card-title"><a href="/chart/qm.eyJrIjoiUXVlcnlNZWFzdXJlbWVudCIsImRhdGFzZXQiOiJ0cGNoIiwiZGF0YXNldF92YXJpYW50IjpudWxsLCJzY2FsZV9mYWN0b3IiOiIxIiwic3RvcmFnZSI6Im52bWUiLCJxdWVyeV9pZHgiOjJ9">Q2</a><span class="chart-badge chart-badge--downsampled" data-role="downsample-badge" hidden></span></h3><div class="toolbar toolbar--card" aria-label="Chart controls"><div class="toolbar-group" role="group" aria-label="Visible commits"><span class="toolbar-label">Show</span><input class="toolbar-slider" id="scope-slider-4" type="range" min="5" max="100" step="1" value="100" data-role="scope-slider" aria-label="Custom commit window"></div><div class="toolbar-group" role="group" aria-label="Y-axis scale"><span class="toolbar-label">Y</span><button class="toolbar-btn toolbar-btn--active" type="button" data-y="linear">linear</button><button class="toolbar-btn" type="button" data-y="log">log</button></div></div><div class="chart-tooltip-host"></div><div class="chart-wrap"><canvas data-chart-index="4"></canvas></div><div class="chart-range-strip" data-chart-index="4" data-role="range-strip" aria-label="Visible commit range" role="slider"><div class="chart-range-strip-track"><div class="chart-range-strip-window" data-role="range-window"><span class="chart-range-strip-handle chart-range-strip-handle--left" data-role="range-handle-left" aria-hidden="true"></span><span class="chart-range-strip-handle chart-range-strip-handle--right" data-role="range-handle-right" aria-hidden="true"></span></div></div></div></section></div></section><section class="group-details" data-group-name="cohere-large-10m / partitioned" data-group-slug="vsg.eyJrIjoiVmVjdG9yU2VhcmNoR3JvdXAiLCJkYXRhc2V0IjoiY29oZXJlLWxhcmdlLTEwbSIsImxheW91dCI6InBhcnRpdGlvbmVkIn0" data-artifact-generation="88da2a7ec8f3f538" data-group-shard-count="1" data-group-shard-prefix="/api/artifacts/88da2a7ec8f3f538/groups/vsg.eyJrIjoiVmVjdG9yU2VhcmNoR3JvdXAiLCJkYXRhc2V0IjoiY29oZXJlLWxhcmdlLTEwbSIsImxheW91dCI6InBhcnRpdGlvbmVkIn0/shards/"><details class="group-disclosure"><summary class="group-summary"><span class="group-summary-row"><span class="group-name">cohere-large-10m / partitioned</span><span class="group-count">1 chart</span></span></summary></details><section class="group-toolbar" data-role="group-toolbar"><div class="toolbar-group group-toolbar-y" role="group" aria-label="Group Y-axis scale"><span class="toolbar-label">Y</span><button class="toolbar-btn toolbar-btn--active" type="button" data-group-y="linear">linear</button><button class="toolbar-btn" type="button" data-group-y="log">log</button></div><div class="group-filter-dropdown" data-role="group-filter-dropdown"><button class="control-btn filter-trigger group-filter-trigger" type="button" data-role="group-filter-trigger" aria-haspopup="true" aria-expanded="false"><svg class="btn-icon" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><polygon points="22 3 2 3 10 12.46 10 19 14 21 14 12.46 22 3"></polygon></svg><span>Filter series</span></button><div class="filter-panel group-filter-panel" data-role="group-filter-panel" hidden><div class="global-filter-row group-macro-row"><span class="global-filter-label">Engine</span><button class="filter-chip filter-chip--all" type="button" data-group-filter="engine" data-value="*" aria-pressed="false">all</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="engine" data-value="datafusion" aria-pressed="true">datafusion</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="engine" data-value="duckdb" aria-pressed="true">duckdb</button></div><div class="global-filter-row group-macro-row"><span class="global-filter-label">Format</span><button class="filter-chip filter-chip--all" type="button" data-group-filter="format" data-value="*" aria-pressed="false">all</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="format" data-value="parquet" aria-pressed="true">parquet</button><button class="filter-chip filter-chip--active" type="button" data-group-filter="format" data-value="vortex-file-compressed" aria-pressed="true">vortex-file-compressed</button></div><div class="global-filter-row group-series-row"><span class="global-filter-label">Series</span><button class="filter-chip filter-chip--all" type="button" data-group-filter="series" data-value="*" aria-pressed="false">all</button><div class="group-series-chips" data-role="group-series-chips"></div></div></div></div><button class="group-toolbar-reset" type="button" data-role="group-toolbar-reset">Reset group</button></section><div class="chart-grid"><section class="chart-card" data-chart-index="5" data-chart-slug="vsr.eyJrIjoiVmVjdG9yU2VhcmNoIiwiZGF0YXNldCI6ImNvaGVyZS1sYXJnZS0xMG0iLCJsYXlvdXQiOiJwYXJ0aXRpb25lZCIsInRocmVzaG9sZCI6MC43NX0"><h3 class="chart-card-title"><a href="/chart/vsr.eyJrIjoiVmVjdG9yU2VhcmNoIiwiZGF0YXNldCI6ImNvaGVyZS1sYXJnZS0xMG0iLCJsYXlvdXQiOiJwYXJ0aXRpb25lZCIsInRocmVzaG9sZCI6MC43NX0">threshold=0.75</a><span class="chart-badge chart-badge--downsampled" data-role="downsample-badge" hidden></span></h3><div class="toolbar toolbar--card" aria-label="Chart controls"><div class="toolbar-group" role="group" aria-label="Visible commits"><span class="toolbar-label">Show</span><input class="toolbar-slider" id="scope-slider-5" type="range" min="5" max="100" step="1" value="100" data-role="scope-slider" aria-label="Custom commit window"></div><div class="toolbar-group" role="group" aria-label="Y-axis scale"><span class="toolbar-label">Y</span><button class="toolbar-btn toolbar-btn--active" type="button" data-y="linear">linear</button><button class="toolbar-btn" type="button" data-y="log">log</button></div></div><div class="chart-tooltip-host"></div><div class="chart-wrap"><canvas data-chart-index="5"></canvas></div><div class="chart-range-strip" data-chart-index="5" data-role="range-strip" aria-label="Visible commit range" role="slider"><div class="chart-range-strip-track"><div class="chart-range-strip-window" data-role="range-window"><span class="chart-range-strip-handle chart-range-strip-handle--left" data-role="range-handle-left" aria-hidden="true"></span><span class="chart-range-strip-handle chart-range-strip-handle--right" data-role="range-handle-right" aria-hidden="true"></span></div></div></div></section></div></section><noscript><p class="no-script">JavaScript is required to render the charts.</p></noscript></main><footer class="site-footer"><span class="site-footer-label">build </span><a class="site-footer-sha" href="https://github.com/vortex-data/vortex/commit/<build-sha>" rel="noopener noreferrer" target="_blank"><code><build-sha></code></a></footer><script src="/static/chart.umd.js?v=bench-v3-ui-27" defer></script><script src="/static/chartjs-plugin-zoom.umd.min.js?v=bench-v3-ui-27" defer></script><script src="/static/chart-init.js?v=bench-v3-ui-27" defer></script></body></html>
diff --git a/benchmarks-website/server/tests/snapshots/landing_page_filter_bar.snap b/benchmarks-website/server/tests/snapshots/landing_page_filter_bar.snap
deleted file mode 100644
index 1a995f8a01f..00000000000
--- a/benchmarks-website/server/tests/snapshots/landing_page_filter_bar.snap
+++ /dev/null
@@ -1,5 +0,0 @@
----
-source: benchmarks-website/server/tests/web_ui.rs
-expression: filter_bar_section(&body)
----
-<div class="filter-dropdown" data-role="global-filter-bar"><button class="control-btn filter-trigger" type="button" data-role="filter-trigger" aria-haspopup="true" aria-expanded="false"><svg class="btn-icon" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><polygon points="22 3 2 3 10 12.46 10 19 14 21 14 12.46 22 3"></polygon></svg><span>Filters</span></button><div class="filter-panel" data-role="filter-panel" hidden><div class="global-filter-row"><span class="global-filter-label">Engine</span><button class="filter-chip filter-chip--all" type="button" data-filter="engine" data-value="*" aria-pressed="false">all</button><button class="filter-chip filter-chip--active" type="button" data-filter="engine" data-value="datafusion" aria-pressed="true">datafusion</button><button class="filter-chip filter-chip--active" type="button" data-filter="engine" data-value="duckdb" aria-pressed="true">duckdb</button></div><div class="global-filter-row"><span class="global-filter-label">Format</span><button class="filter-chip filter-chip--all" type="button" data-filter="format" data-value="*" aria-pressed="false">all</button><button class="filter-chip filter-chip--active" type="button" data-filter="format" data-value="parquet" aria-pressed="true">parquet</button><button class="filter-chip filter-chip--active" type="button" data-filter="format" data-value="vortex-file-compressed" aria-pressed="true">vortex-file-compressed</button></div></div></div>
diff --git a/benchmarks-website/server/tests/static_assets.rs b/benchmarks-website/server/tests/static_assets.rs
deleted file mode 100644
index 8533419a416..00000000000
--- a/benchmarks-website/server/tests/static_assets.rs
+++ /dev/null
@@ -1,211 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Integration tests for the bundled `/static/...` asset routes plus the
-//! response compression layer.
-
-mod common;
-
-use std::io::Read as _;
-
-use anyhow::Result;
-use flate2::read::GzDecoder;
-
-use self::common::Server;
-use self::common::seed;
-
-#[tokio::test]
-async fn static_assets_are_served() -> Result<()> {
-    let server = Server::start().await?;
-    let client = reqwest::Client::new();
-
-    for (path, ct_prefix) in [
-        ("/static/chart.umd.js", "application/javascript"),
-        (
-            "/static/chartjs-plugin-zoom.umd.min.js",
-            "application/javascript",
-        ),
-        ("/static/chart-init.js", "application/javascript"),
-        ("/static/style.css", "text/css"),
-        ("/static/icon-light.png", "image/png"),
-        ("/static/icon-dark.png", "image/png"),
-        ("/Vortex_Black_NoBG.png", "image/png"),
-        ("/Vortex_White_NoBG.png", "image/png"),
-    ] {
-        let resp = client.get(server.url(path)).send().await?;
-        assert_eq!(resp.status(), 200, "GET {path} should be 200");
-        let ct = resp
-            .headers()
-            .get(reqwest::header::CONTENT_TYPE)
-            .and_then(|v| v.to_str().ok())
-            .unwrap_or_default()
-            .to_string();
-        assert!(
-            ct.starts_with(ct_prefix),
-            "GET {path}: content-type {ct:?} should start with {ct_prefix:?}"
-        );
-        let cache_control = resp
-            .headers()
-            .get(reqwest::header::CACHE_CONTROL)
-            .and_then(|v| v.to_str().ok())
-            .unwrap_or_default()
-            .to_string();
-        assert!(
-            cache_control.contains("no-cache"),
-            "GET {path}: static assets should revalidate so UI CSS/JS changes are not stale"
-        );
-        let bytes = resp.bytes().await?;
-        assert!(!bytes.is_empty(), "GET {path}: body must not be empty");
-    }
-    Ok(())
-}
-
-#[tokio::test]
-async fn chart_init_uses_bounded_group_hydration() -> Result<()> {
-    let server = Server::start().await?;
-    let client = reqwest::Client::new();
-
-    let js = client
-        .get(server.url("/static/chart-init.js"))
-        .send()
-        .await?
-        .text()
-        .await?;
-
-    assert!(
-        js.contains("data-group-shard-prefix") && js.contains("fetchGroupShard"),
-        "landing hydration should fetch versioned group shard artifacts"
-    );
-    assert!(
-        !js.contains(r#""/api/group/""#),
-        "landing hydration should not put whole-group payloads on the hot path"
-    );
-    assert!(
-        js.contains(r#""/api/chart/""#) && js.contains("ensureFullHistory"),
-        "chart-init should use /api/chart for queued full-history warmup"
-    );
-    assert!(
-        js.contains("HYDRATION_CONCURRENCY") && js.contains("FULL_HISTORY_CONCURRENCY"),
-        "landing hydration and full-history warmup should bound per-tab fanout"
-    );
-    assert!(
-        !js.contains("startBackgroundPrefetch();"),
-        "chart-init must not fan out full-history chart fetches on page load"
-    );
-    assert!(
-        js.contains("normalizeChartPayload"),
-        "chart-init should normalize latest-100 payloads onto a virtual full-history x-axis"
-    );
-    assert!(
-        js.contains("queueGroupFullHistory"),
-        "opening a group should queue full-history fetches for that group"
-    );
-    assert!(
-        !js.contains("function maybeRefetchFullPayload"),
-        "full-history fetches should not depend on the old covers-all interaction gate"
-    );
-    assert!(
-        !js.contains("WIDE_DEFAULT_GROUPS"),
-        "group-open hydration should default every group to the latest-100 window"
-    );
-    Ok(())
-}
-
-/// Every response — landing HTML, chart JSON, bundled JS — flows through
-/// `tower-http`'s `CompressionLayer` so a client advertising
-/// `Accept-Encoding: gzip` gets a gzipped (or brotli) body. The
-/// reqwest dev-dependency is built without `gzip`/`brotli` features, so the
-/// transport hands us the compressed bytes verbatim and we can both inspect
-/// the `content-encoding` response header and decompress the body manually
-/// to confirm it matches the uncompressed snapshot.
-#[tokio::test]
-async fn responses_are_compressed_when_client_accepts_gzip() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let client = reqwest::Client::new();
-
-    // 1. Landing HTML.
-    let plain_body = client.get(server.url("/")).send().await?.text().await?;
-    let resp = client
-        .get(server.url("/"))
-        .header(reqwest::header::ACCEPT_ENCODING, "gzip")
-        .send()
-        .await?;
-    assert_eq!(resp.status(), 200);
-    let encoding = resp
-        .headers()
-        .get(reqwest::header::CONTENT_ENCODING)
-        .and_then(|v| v.to_str().ok())
-        .unwrap_or_default()
-        .to_string();
-    assert_eq!(
-        encoding, "gzip",
-        "GET / with Accept-Encoding: gzip should respond with gzip"
-    );
-    let compressed = resp.bytes().await?;
-    assert!(
-        compressed.len() < plain_body.len(),
-        "compressed body ({} B) should be smaller than plain body ({} B)",
-        compressed.len(),
-        plain_body.len(),
-    );
-    let mut decoded = String::new();
-    GzDecoder::new(&compressed[..]).read_to_string(&mut decoded)?;
-    assert_eq!(
-        decoded, plain_body,
-        "gzipped landing body should decompress to the uncompressed body"
-    );
-
-    // 2. Bundled JS — the heaviest static asset; gzip is the whole point.
-    let plain_js = client
-        .get(server.url("/static/chart.umd.js"))
-        .send()
-        .await?
-        .bytes()
-        .await?;
-    let js_resp = client
-        .get(server.url("/static/chart.umd.js"))
-        .header(reqwest::header::ACCEPT_ENCODING, "gzip")
-        .send()
-        .await?;
-    assert_eq!(js_resp.status(), 200);
-    let js_encoding = js_resp
-        .headers()
-        .get(reqwest::header::CONTENT_ENCODING)
-        .and_then(|v| v.to_str().ok())
-        .unwrap_or_default()
-        .to_string();
-    assert_eq!(
-        js_encoding, "gzip",
-        "/static/chart.umd.js must compress so the cold load isn't dominated by ~200KB of JS"
-    );
-    let compressed_js = js_resp.bytes().await?;
-    let mut decoded_js = Vec::new();
-    GzDecoder::new(&compressed_js[..]).read_to_end(&mut decoded_js)?;
-    assert_eq!(
-        decoded_js,
-        plain_js.as_ref(),
-        "decompressed chart.umd.js should match the unencoded body byte-for-byte"
-    );
-
-    // 3. Brotli is also offered when the client prefers it.
-    let br_resp = client
-        .get(server.url("/"))
-        .header(reqwest::header::ACCEPT_ENCODING, "br")
-        .send()
-        .await?;
-    assert_eq!(br_resp.status(), 200);
-    let br_encoding = br_resp
-        .headers()
-        .get(reqwest::header::CONTENT_ENCODING)
-        .and_then(|v| v.to_str().ok())
-        .unwrap_or_default()
-        .to_string();
-    assert_eq!(
-        br_encoding, "br",
-        "GET / with Accept-Encoding: br should respond with brotli"
-    );
-
-    Ok(())
-}
diff --git a/benchmarks-website/server/tests/web_ui.rs b/benchmarks-website/server/tests/web_ui.rs
deleted file mode 100644
index 83edf2c86e6..00000000000
--- a/benchmarks-website/server/tests/web_ui.rs
+++ /dev/null
@@ -1,506 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Integration tests for the v3 web UI features that span the API and
-//! HTML routes:
-//!
-//! - **Per-group hover descriptions** (Task A): editorial blurbs port from
-//!   v2's `BENCHMARK_DESCRIPTIONS` + `getBenchmarkDescription`. Asserted on
-//!   the landing page and on the `/group/{slug}` permalink.
-//! - **Partial-coverage commits** (Task B): a chart's x-axis includes
-//!   commits that have NO row in the fact table for this chart, so
-//!   missing measurements render as visible gaps rather than silently
-//!   bridged lines.
-
-mod common;
-
-use anyhow::Context as _;
-use anyhow::Result;
-use serde_json::Value;
-use serde_json::json;
-
-use self::common::Server;
-use self::common::TOKEN;
-use self::common::pick_chart_slug;
-use self::common::pick_group_slug;
-use self::common::seed;
-use self::common::wait_for_materialized_first_chart_commits;
-
-// =============================================================================
-// Task A — per-group hover descriptions
-// =============================================================================
-
-/// The landing page renders a small ⓘ icon next to every group title that
-/// has a canonical description, with the description surfaced via the
-/// `data-tooltip` attribute (CSS-only hover/focus tooltip). The description
-/// also appears on `/api/groups`.
-#[tokio::test]
-async fn landing_page_renders_group_descriptions() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let client = reqwest::Client::new();
-    let body = client.get(server.url("/")).send().await?.text().await?;
-
-    // Random Access — verbatim v2 description.
-    assert!(
-        body.contains(r#"data-tooltip="Tests performance of selecting arbitrary row indices from a file on NVMe storage""#),
-        "Random Access description must appear as a hover tooltip on the landing page"
-    );
-    // Compression — verbatim v2 description (the longer wording, not the
-    // shorter `getBenchmarkDescription` fallback).
-    assert!(
-        body.contains(r#"data-tooltip="Measures encoding and decoding throughput (MB/s) for Vortex files and Parquet files (with zstd page compression)""#),
-        "Compression description must appear as a hover tooltip on the landing page"
-    );
-    // Compression Size — verbatim v2 description.
-    assert!(
-        body.contains(r#"data-tooltip="Compares compressed file sizes and compression ratios across different encoding strategies""#),
-        "Compression Size description must appear as a hover tooltip on the landing page"
-    );
-    // TPC-H NVMe SF=1 — derived description with scale-bytes annotation.
-    assert!(
-        body.contains(
-            r#"data-tooltip="TPC-H benchmark queries on local NVMe storage at SF=1 (~1GB of data)""#
-        ),
-        "TPC-H description with scale-bytes annotation must appear on the landing page"
-    );
-
-    // The icon itself is keyboard-focusable + role-annotated for a11y.
-    assert!(
-        body.contains(r#"<span class="group-info-icon""#),
-        "info icon must render with the group-info-icon class"
-    );
-    assert!(
-        body.contains(r#"tabindex="0""#) && body.contains(r#"role="note""#),
-        "info icon must be keyboard-focusable with role=\"note\""
-    );
-    assert!(
-        body.contains(r#"aria-label="Tests performance of selecting arbitrary row indices from a file on NVMe storage""#),
-        "info icon must duplicate the description as aria-label"
-    );
-
-    Ok(())
-}
-
-/// The `/group/{slug}` permalink page renders the same description as the
-/// landing page tooltip. Render through the chart-meta header so it's
-/// discoverable next to the chart count.
-#[tokio::test]
-async fn group_page_renders_description() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let client = reqwest::Client::new();
-    let slug = pick_group_slug(&server, |s| s == "Random Access").await?;
-    let body = client
-        .get(server.url(&format!("/group/{slug}")))
-        .send()
-        .await?
-        .text()
-        .await?;
-
-    assert!(
-        body.contains(r#"data-tooltip="Tests performance of selecting arbitrary row indices from a file on NVMe storage""#),
-        "group permalink page must render the same description tooltip as the landing page"
-    );
-    assert!(
-        body.contains(r#"<span class="group-info-icon""#),
-        "group permalink page must render the info-icon span"
-    );
-    Ok(())
-}
-
-/// Vector-search groups have no canonical description in v2, so the v3
-/// renderer leaves the icon out (rather than making one up).
-#[tokio::test]
-async fn vector_search_group_has_no_description_icon() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let client = reqwest::Client::new();
-    let body = client.get(server.url("/")).send().await?.text().await?;
-
-    // Locate the vector-search section and assert no info-icon inside its
-    // disclosure summary.
-    let needle = r#"data-group-name="cohere-large-10m / partitioned""#;
-    let start = body.find(needle).context("vector-search section present")?;
-    // The `<summary>` tag is the disclosure header; we want the slice
-    // between this section's start and the end of its `<summary>`.
-    let summary_end = body[start..]
-        .find("</summary>")
-        .map(|p| start + p)
-        .context("section contains </summary>")?;
-    let summary = &body[start..summary_end];
-    assert!(
-        !summary.contains("group-info-icon"),
-        "vector-search group should not render an info-icon (no canonical description), got: {summary}"
-    );
-    Ok(())
-}
-
-/// `/api/groups` carries the description on every group entry as a `description`
-/// field, so external API consumers can render their own UI without having to
-/// hard-code v2's description list.
-#[tokio::test]
-async fn groups_api_carries_description_field() -> Result<()> {
-    let server = Server::start().await?;
-    seed(&server).await?;
-
-    let client = reqwest::Client::new();
-    let groups: Value = client
-        .get(server.url("/api/groups"))
-        .send()
-        .await?
-        .json()
-        .await?;
-    let arr = groups["groups"].as_array().context("groups[] array")?;
-    let by_name = |n: &str| {
-        arr.iter()
-            .find(|g| g["name"].as_str() == Some(n))
-            .with_context(|| format!("group {n:?} present"))
-    };
-    assert_eq!(
-        by_name("Random Access")?["description"].as_str(),
-        Some("Tests performance of selecting arbitrary row indices from a file on NVMe storage"),
-    );
-    assert_eq!(
-        by_name("TPC-H (NVMe) (SF=1)")?["description"].as_str(),
-        Some("TPC-H benchmark queries on local NVMe storage at SF=1 (~1GB of data)"),
-    );
-    // Vector-search group has no canonical description; the `description`
-    // key should be absent (skip_serializing_if).
-    let vsg = by_name("cohere-large-10m / partitioned")?;
-    assert!(
-        vsg.get("description").is_none(),
-        "vector-search group should not carry a description field, got: {vsg}"
-    );
-    Ok(())
-}
-
-// =============================================================================
-// Task B — partial-coverage commits
-// =============================================================================
-
-/// Build an envelope that records a `random_access_time` measurement only
-/// for the listed `(format, value_ns)` pairs. The fixture commits' SHAs are
-/// deterministic so tests can assert on them.
-fn ra_envelope(sha: &str, ts: &str, msg: &str, rows: &[(&str, i64)]) -> Value {
-    json!({
-        "run_meta": {
-            "benchmark_id": "partial-coverage-fixture",
-            "schema_version": 1,
-            "started_at": ts
-        },
-        "commit": {
-            "sha": sha,
-            "timestamp": ts,
-            "message": msg,
-            "author_name": "Test Author",
-            "author_email": "author@example.com",
-            "committer_name": "Test Committer",
-            "committer_email": "committer@example.com",
-            "tree_sha": "fedcba9876543210fedcba9876543210fedcba98",
-            "url": format!("https://github.com/vortex-data/vortex/commit/{sha}")
-        },
-        "records": rows.iter().map(|(format, value_ns)| json!({
-            "kind": "random_access_time",
-            "commit_sha": sha,
-            "dataset": "taxi",
-            "format": format,
-            "value_ns": value_ns,
-            "all_runtimes_ns": [value_ns]
-        })).collect::<Vec<_>>()
-    })
-}
-
-/// Regression test for "charts have invisible gaps where commits should be."
-///
-/// Seed three commits A, B, C in chronological order:
-///   * A — series X and Y both have data
-///   * B — only series Y has data (X crashed; this is the partial-coverage case)
-///   * C — series X and Y both have data
-///
-/// The chart's `commits[]` must include all three commits (B included),
-/// and series X's value at B must be `null`. Before the fix the chart
-/// silently dropped B because `SeriesAccumulator::ensure_commit` only
-/// registered commits that had at least one row in the fact table.
-#[tokio::test]
-async fn chart_includes_commits_with_partial_series_coverage() -> Result<()> {
-    let server = Server::start().await?;
-    let client = reqwest::Client::new();
-
-    let envelopes = [
-        ra_envelope(
-            "aaaa111111111111111111111111111111111111",
-            "2026-04-23T12:00:00Z",
-            "A: both series",
-            &[("vortex-file-compressed", 500), ("parquet", 1_000)],
-        ),
-        ra_envelope(
-            "bbbb222222222222222222222222222222222222",
-            "2026-04-24T12:00:00Z",
-            "B: only parquet (vortex crashed)",
-            &[("parquet", 1_100)],
-        ),
-        ra_envelope(
-            "cccc333333333333333333333333333333333333",
-            "2026-04-25T12:00:00Z",
-            "C: both series",
-            &[("vortex-file-compressed", 600), ("parquet", 1_200)],
-        ),
-    ];
-    for env in &envelopes {
-        let resp = client
-            .post(server.url("/api/ingest"))
-            .bearer_auth(TOKEN)
-            .json(env)
-            .send()
-            .await?;
-        anyhow::ensure!(
-            resp.status().is_success(),
-            "seed ingest failed: {}",
-            resp.status()
-        );
-    }
-    wait_for_materialized_first_chart_commits(&server, 3).await?;
-
-    let slug = pick_chart_slug(&server, |s| s == "Random Access").await?;
-    let chart: Value = client
-        .get(server.url(&format!("/api/chart/{slug}")))
-        .send()
-        .await?
-        .json()
-        .await?;
-
-    let commits = chart["commits"].as_array().context("commits[] array")?;
-    let shas: Vec<&str> = commits.iter().filter_map(|c| c["sha"].as_str()).collect();
-    assert_eq!(
-        shas,
-        vec![
-            "aaaa111111111111111111111111111111111111",
-            "bbbb222222222222222222222222222222222222",
-            "cccc333333333333333333333333333333333333",
-        ],
-        "all three commits must appear in commits[], including the partial-coverage commit B"
-    );
-
-    // Series X (vortex-file-compressed) has data at A and C, NULL at B.
-    let vortex = chart["series"]["vortex-file-compressed"]
-        .as_array()
-        .context("vortex-file-compressed series array")?;
-    assert_eq!(vortex.len(), 3, "series array aligns with commits[]");
-    assert_eq!(vortex[0].as_f64(), Some(500.0));
-    assert!(
-        vortex[1].is_null(),
-        "vortex-file-compressed must be null at the partial-coverage commit, got {:?}",
-        vortex[1],
-    );
-    assert_eq!(vortex[2].as_f64(), Some(600.0));
-
-    // Series Y (parquet) has data at all three commits.
-    let parquet = chart["series"]["parquet"]
-        .as_array()
-        .context("parquet series array")?;
-    assert_eq!(parquet[0].as_f64(), Some(1_000.0));
-    assert_eq!(parquet[1].as_f64(), Some(1_100.0));
-    assert_eq!(parquet[2].as_f64(), Some(1_200.0));
-
-    Ok(())
-}
-
-/// A commit with NO row in the chart's fact table (every benchmark crashed
-/// for that commit) still appears on the chart's x-axis as long as it falls
-/// within the chart's window — i.e. ≥ the earliest commit that has data.
-///
-/// Seed two commits with random-access data and one commit that only has a
-/// `compression_size` row. The compression-size-only commit is in the
-/// `commits` dim but has nothing in `random_access_times`, so the random-
-/// access chart should still place it on the x-axis with NULL for every
-/// series.
-#[tokio::test]
-async fn chart_includes_commits_with_zero_rows_in_fact_table() -> Result<()> {
-    let server = Server::start().await?;
-    let client = reqwest::Client::new();
-
-    // Commit A: random-access only.
-    let env_a = ra_envelope(
-        "aaaa111111111111111111111111111111111111",
-        "2026-04-23T12:00:00Z",
-        "A",
-        &[("parquet", 1_000)],
-    );
-    // Commit B (chronologically between A and C): a compression_size row,
-    // nothing in random_access_times.
-    let env_b = json!({
-        "run_meta": {
-            "benchmark_id": "partial-coverage-fixture",
-            "schema_version": 1,
-            "started_at": "2026-04-24T12:00:00Z"
-        },
-        "commit": {
-            "sha": "bbbb222222222222222222222222222222222222",
-            "timestamp": "2026-04-24T12:00:00Z",
-            "message": "B: random-access did not run (only compression_size emitted)",
-            "author_name": "Test Author",
-            "author_email": "author@example.com",
-            "committer_name": "Test Committer",
-            "committer_email": "committer@example.com",
-            "tree_sha": "fedcba9876543210fedcba9876543210fedcba98",
-            "url": "https://github.com/vortex-data/vortex/commit/bbbb222222222222222222222222222222222222"
-        },
-        "records": [
-            {
-                "kind": "compression_size",
-                "commit_sha": "bbbb222222222222222222222222222222222222",
-                "dataset": "tpch-lineitem",
-                "format": "parquet",
-                "value_bytes": 4_000,
-            },
-        ],
-    });
-    // Commit C: random-access again.
-    let env_c = ra_envelope(
-        "cccc333333333333333333333333333333333333",
-        "2026-04-25T12:00:00Z",
-        "C",
-        &[("parquet", 1_200)],
-    );
-
-    for env in [&env_a, &env_b, &env_c] {
-        let resp = client
-            .post(server.url("/api/ingest"))
-            .bearer_auth(TOKEN)
-            .json(env)
-            .send()
-            .await?;
-        anyhow::ensure!(
-            resp.status().is_success(),
-            "seed ingest failed: {}",
-            resp.status()
-        );
-    }
-    wait_for_materialized_first_chart_commits(&server, 3).await?;
-
-    let slug = pick_chart_slug(&server, |s| s == "Random Access").await?;
-    let chart: Value = client
-        .get(server.url(&format!("/api/chart/{slug}")))
-        .send()
-        .await?
-        .json()
-        .await?;
-
-    let shas: Vec<&str> = chart["commits"]
-        .as_array()
-        .context("commits[] array")?
-        .iter()
-        .filter_map(|c| c["sha"].as_str())
-        .collect();
-    assert_eq!(
-        shas,
-        vec![
-            "aaaa111111111111111111111111111111111111",
-            "bbbb222222222222222222222222222222222222",
-            "cccc333333333333333333333333333333333333",
-        ],
-        "the commit with zero rows in the fact table must still appear in commits[]"
-    );
-
-    // The parquet series has data only at A and C.
-    let parquet = chart["series"]["parquet"]
-        .as_array()
-        .context("parquet series array")?;
-    assert_eq!(parquet.len(), 3);
-    assert_eq!(parquet[0].as_f64(), Some(1_000.0));
-    assert!(
-        parquet[1].is_null(),
-        "parquet must be null at the zero-rows commit"
-    );
-    assert_eq!(parquet[2].as_f64(), Some(1_200.0));
-
-    Ok(())
-}
-
-/// Commits older than the earliest fact-table row for this chart are NOT
-/// included on the x-axis. Without this lower bound a chart's first commit
-/// could be from before the benchmark even existed — the spec calls this
-/// out explicitly as "Beware: don't accidentally include EVERY commit ever."
-#[tokio::test]
-async fn chart_excludes_commits_before_first_fact_row() -> Result<()> {
-    let server = Server::start().await?;
-    let client = reqwest::Client::new();
-
-    // Commit A: a `compression_time` row (random-access does not exist for A).
-    let env_a = json!({
-        "run_meta": {
-            "benchmark_id": "partial-coverage-fixture",
-            "schema_version": 1,
-            "started_at": "2026-04-22T12:00:00Z"
-        },
-        "commit": {
-            "sha": "aaaa111111111111111111111111111111111111",
-            "timestamp": "2026-04-22T12:00:00Z",
-            "message": "A: pre-history of the random-access bench",
-            "author_name": "Test Author",
-            "author_email": "author@example.com",
-            "committer_name": "Test Committer",
-            "committer_email": "committer@example.com",
-            "tree_sha": "fedcba9876543210fedcba9876543210fedcba98",
-            "url": "https://github.com/vortex-data/vortex/commit/aaaa111111111111111111111111111111111111"
-        },
-        "records": [
-            {
-                "kind": "compression_time",
-                "commit_sha": "aaaa111111111111111111111111111111111111",
-                "dataset": "tpch-lineitem",
-                "format": "parquet",
-                "op": "encode",
-                "value_ns": 9_000,
-                "all_runtimes_ns": [9_000],
-            },
-        ],
-    });
-    // Commit B: first random-access row appears.
-    let env_b = ra_envelope(
-        "bbbb222222222222222222222222222222222222",
-        "2026-04-23T12:00:00Z",
-        "B: random-access bench begins",
-        &[("parquet", 1_000)],
-    );
-
-    for env in [&env_a, &env_b] {
-        let resp = client
-            .post(server.url("/api/ingest"))
-            .bearer_auth(TOKEN)
-            .json(env)
-            .send()
-            .await?;
-        anyhow::ensure!(
-            resp.status().is_success(),
-            "seed ingest failed: {}",
-            resp.status()
-        );
-    }
-    wait_for_materialized_first_chart_commits(&server, 1).await?;
-
-    let slug = pick_chart_slug(&server, |s| s == "Random Access").await?;
-    let chart: Value = client
-        .get(server.url(&format!("/api/chart/{slug}")))
-        .send()
-        .await?
-        .json()
-        .await?;
-
-    let shas: Vec<&str> = chart["commits"]
-        .as_array()
-        .context("commits[] array")?
-        .iter()
-        .filter_map(|c| c["sha"].as_str())
-        .collect();
-    assert_eq!(
-        shas,
-        vec!["bbbb222222222222222222222222222222222222"],
-        "commit A predates the first random-access row, so it must not be on the x-axis"
-    );
-    Ok(())
-}
diff --git a/benchmarks/compress-bench/src/main.rs b/benchmarks/compress-bench/src/main.rs
index ce48001abb5..8d9fa73f915 100644
--- a/benchmarks/compress-bench/src/main.rs
+++ b/benchmarks/compress-bench/src/main.rs
@@ -134,6 +134,14 @@ async fn run_compress(
         StructListOfInts::new(100, 1000, 50),
         StructListOfInts::new(1000, 1000, 50),
         StructListOfInts::new(10000, 1000, 50),
+        // See https://github.com/vortex-data/vortex/issues/8330
+        // Very wide file: project a fixed 10k columns out of 100k, across 10 chunks.
+        // StructListOfInts::new_with_projection(
+        //     READ_PROJECTION_ROOT_COLUMNS,
+        //     1000,
+        //     10,
+        //     Some(READ_PROJECTION_COLUMNS),
+        // ),
     ];
 
     let datasets: Vec<&dyn Dataset> = [
diff --git a/benchmarks/compress-bench/src/parquet.rs b/benchmarks/compress-bench/src/parquet.rs
index aaf64f81c94..cab4f753948 100644
--- a/benchmarks/compress-bench/src/parquet.rs
+++ b/benchmarks/compress-bench/src/parquet.rs
@@ -13,12 +13,14 @@ use arrow_schema::Schema;
 use async_trait::async_trait;
 use bytes::Bytes;
 use parquet::arrow::ArrowWriter;
+use parquet::arrow::ProjectionMask;
 use parquet::arrow::arrow_reader::ParquetRecordBatchReaderBuilder;
 use parquet::basic::Compression;
 use parquet::basic::ZstdLevel;
 use parquet::file::properties::WriterProperties;
 use vortex_bench::Format;
 use vortex_bench::compress::Compressor;
+use vortex_bench::compress::read_projection;
 
 /// Compressor implementation for Parquet format with ZSTD compression.
 pub struct ParquetCompressor {
@@ -108,7 +110,12 @@ pub fn parquet_compress_write(
 
 #[inline(never)]
 pub fn parquet_decompress_read(buf: Bytes) -> anyhow::Result<usize> {
-    let builder = ParquetRecordBatchReaderBuilder::try_new(buf)?;
+    let mut builder = ParquetRecordBatchReaderBuilder::try_new(buf)?;
+    if let Some(cols) = read_projection(builder.schema().fields().len()) {
+        // Project the given top-level (root) columns.
+        let mask = ProjectionMask::roots(builder.parquet_schema(), cols.iter().copied());
+        builder = builder.with_projection(mask);
+    }
     let reader = builder.build()?;
     let mut nbytes = 0;
     for batch in reader {
diff --git a/benchmarks/compress-bench/src/vortex.rs b/benchmarks/compress-bench/src/vortex.rs
index 9d548fd60ec..87416cdf924 100644
--- a/benchmarks/compress-bench/src/vortex.rs
+++ b/benchmarks/compress-bench/src/vortex.rs
@@ -13,11 +13,15 @@ use bytes::Bytes;
 use futures::StreamExt;
 use futures::pin_mut;
 use vortex::array::IntoArray;
+use vortex::dtype::FieldNames;
+use vortex::expr::root;
+use vortex::expr::select;
 use vortex::file::OpenOptionsSessionExt;
 use vortex::file::WriteOptionsSessionExt;
 use vortex_bench::Format;
 use vortex_bench::SESSION;
 use vortex_bench::compress::Compressor;
+use vortex_bench::compress::read_projection;
 use vortex_bench::conversions::parquet_to_vortex_chunks;
 
 /// Compressor implementation for Vortex format.
@@ -58,7 +62,16 @@ impl Compressor for VortexCompressor {
         // Now decompress
         let start = Instant::now();
         let data = Bytes::from(buf);
-        let scan = SESSION.open_options().open_buffer(data)?.scan()?;
+        let mut scan = SESSION.open_options().open_buffer(data)?.scan()?;
+        let root_columns = scan
+            .dtype()?
+            .as_struct_fields_opt()
+            .map_or(0, |fields| fields.nfields());
+        if let Some(cols) = read_projection(root_columns) {
+            // Columns are named "0".."num_columns-1"; project the given subset.
+            let names: FieldNames = cols.iter().map(|i| i.to_string()).collect();
+            scan = scan.with_projection(select(names, root()));
+        }
         let schema = Arc::new(scan.dtype()?.to_arrow_schema()?);
 
         let stream = scan.into_record_batch_stream(schema)?;
diff --git a/benchmarks/datafusion-bench/src/lib.rs b/benchmarks/datafusion-bench/src/lib.rs
index 469c9be6177..c8353eb1f85 100644
--- a/benchmarks/datafusion-bench/src/lib.rs
+++ b/benchmarks/datafusion-bench/src/lib.rs
@@ -14,7 +14,7 @@ use datafusion::datasource::provider::DefaultTableFactory;
 use datafusion::execution::SessionStateBuilder;
 use datafusion::execution::cache::DefaultListFilesCache;
 use datafusion::execution::cache::cache_manager::CacheManagerConfig;
-use datafusion::execution::cache::cache_unit::DefaultFileStatisticsCache;
+use datafusion::execution::cache::file_statistics_cache::DefaultFileStatisticsCache;
 use datafusion::execution::runtime_env::RuntimeEnvBuilder;
 use datafusion::prelude::SessionConfig;
 use datafusion::prelude::SessionContext;
@@ -37,7 +37,7 @@ pub fn get_session_context() -> SessionContext {
     let file_static_cache = Arc::new(DefaultFileStatisticsCache::default());
     let list_file_cache = Arc::new(DefaultListFilesCache::default());
     let cache_config = CacheManagerConfig::default()
-        .with_files_statistics_cache(Some(file_static_cache))
+        .with_file_statistics_cache(Some(file_static_cache))
         .with_list_files_cache(Some(list_file_cache));
     rt_builder = rt_builder.with_cache_manager(cache_config);
 
diff --git a/benchmarks/datafusion-bench/src/main.rs b/benchmarks/datafusion-bench/src/main.rs
index 52046a03da3..b8f9ac42df6 100644
--- a/benchmarks/datafusion-bench/src/main.rs
+++ b/benchmarks/datafusion-bench/src/main.rs
@@ -278,7 +278,14 @@ async fn register_benchmark_tables<B: Benchmark + ?Sized>(
                     None => config.infer_schema(&session.state()).await?,
                 };
 
-                let listing_table = Arc::new(ListingTable::try_new(config)?);
+                let listing_table = Arc::new(
+                    ListingTable::try_new(config)?.with_cache(
+                        session
+                            .runtime_env()
+                            .cache_manager
+                            .get_file_statistic_cache(),
+                    ),
+                );
 
                 session.register_table(table.name, listing_table)?;
             }
diff --git a/benchmarks/duckdb-bench/src/main.rs b/benchmarks/duckdb-bench/src/main.rs
index b2a4ff1bd15..8ba4937f566 100644
--- a/benchmarks/duckdb-bench/src/main.rs
+++ b/benchmarks/duckdb-bench/src/main.rs
@@ -178,6 +178,11 @@ fn main() -> anyhow::Result<()> {
                 args.threads,
             )?;
             ctx.register_tables(&*benchmark, format)?;
+
+            // Duckdb doesn't support octet_length for strings but we need this
+            // in ClickBench.
+            ctx.execute_query_result("create macro if not exists octet_length(a) as strlen(a)")?;
+
             Ok(ctx)
         },
         |ctx, query_idx, format, query| {
diff --git a/benchmarks/lance-bench/src/compress.rs b/benchmarks/lance-bench/src/compress.rs
index a7732730ef7..4d8df8f24dd 100644
--- a/benchmarks/lance-bench/src/compress.rs
+++ b/benchmarks/lance-bench/src/compress.rs
@@ -20,6 +20,7 @@ use parquet::arrow::arrow_reader::ParquetRecordBatchReaderBuilder;
 use tempfile::TempDir;
 use vortex_bench::Format;
 use vortex_bench::compress::Compressor;
+use vortex_bench::compress::read_projection;
 
 use crate::convert::convert_utf8view_batch;
 use crate::convert::convert_utf8view_schema;
@@ -28,7 +29,13 @@ use crate::convert::convert_utf8view_schema;
 pub async fn lance_decompress_read(path: &str) -> anyhow::Result<usize> {
     // Open the Lance dataset from the filesystem path.
     let dataset = Dataset::open(path).await?;
-    let scanner = dataset.scan();
+    let mut scanner = dataset.scan();
+
+    // Apply the fixed wide-table read projection, if any. Columns are named "0".."n-1".
+    if let Some(cols) = read_projection(dataset.schema().fields.len()) {
+        let names: Vec<String> = cols.iter().map(|i| i.to_string()).collect();
+        scanner.project(&names)?;
+    }
 
     // Convert to a stream of RecordBatches.
     let mut stream = scanner.try_into_stream().await?;
diff --git a/benchmarks/vector-search-bench/Cargo.toml b/benchmarks/vector-search-bench/Cargo.toml
deleted file mode 100644
index 02528526080..00000000000
--- a/benchmarks/vector-search-bench/Cargo.toml
+++ /dev/null
@@ -1,41 +0,0 @@
-[package]
-name = "vector-search-bench"
-description = "Vector similarity search benchmarks for Vortex on public embedding datasets"
-authors.workspace = true
-categories.workspace = true
-edition.workspace = true
-homepage.workspace = true
-include.workspace = true
-keywords.workspace = true
-license.workspace = true
-readme.workspace = true
-repository.workspace = true
-rust-version.workspace = true
-version.workspace = true
-publish = false
-
-[dependencies]
-anyhow = { workspace = true }
-arrow-array = { workspace = true }
-arrow-buffer = { workspace = true }
-arrow-schema = { workspace = true }
-clap = { workspace = true, features = ["derive"] }
-futures = { workspace = true }
-indicatif = { workspace = true }
-parquet = { workspace = true, features = ["async"] }
-rand = { workspace = true }
-rand_distr = { workspace = true }
-serde = { workspace = true, features = ["derive"] }
-tabled = { workspace = true, features = ["std"] }
-tokio = { workspace = true, features = ["full"] }
-tracing = { workspace = true }
-vortex = { workspace = true, features = ["files", "tokio", "unstable_encodings"] }
-vortex-bench = { workspace = true, features = ["unstable_encodings"] }
-vortex-btrblocks = { workspace = true, features = ["unstable_encodings"] }
-vortex-tensor = { workspace = true }
-
-[dev-dependencies]
-tempfile = { workspace = true }
-
-[lints]
-workspace = true
diff --git a/benchmarks/vector-search-bench/scripts/plot-turboquant-distortion.py b/benchmarks/vector-search-bench/scripts/plot-turboquant-distortion.py
deleted file mode 100644
index 6d6b1f22b4f..00000000000
--- a/benchmarks/vector-search-bench/scripts/plot-turboquant-distortion.py
+++ /dev/null
@@ -1,596 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#   "matplotlib",
-# ]
-# ///
-
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-"""Sweep bits-vs-distortion for TurboQuant and plot the curves.
-
-Calls `vector-search-bench distortion` for each (dataset, bits) combination, parses the
-table from stdout, and plots reconstruction NMSE and squared cosine-error curves with
-mean/median/max shown on a log-scaled y-axis.
-
-Each `--dataset` value may optionally pin a train layout with a colon, e.g.
-`--dataset cohere-small-100k:single`, for datasets that host more than one layout.
-
-Usage:
-  uv run benchmarks/vector-search-bench/scripts/plot-turboquant-distortion.py \\
-      --dataset sift-small-500k
-  uv run benchmarks/vector-search-bench/scripts/plot-turboquant-distortion.py \\
-      --dataset sift-small-500k --dataset glove-small-100k --samples 8192
-  uv run benchmarks/vector-search-bench/scripts/plot-turboquant-distortion.py \\
-      --dataset cohere-small-100k:single --bits 1 2 3 4 5 6 7 8 \\
-      --output /tmp/distortion.png
-"""
-
-import argparse
-import math
-import re
-import subprocess
-import sys
-from dataclasses import dataclass
-from pathlib import Path
-
-import matplotlib.pyplot as plt
-from matplotlib.lines import Line2D
-from matplotlib.ticker import MaxNLocator, NullLocator
-
-REPO_ROOT = Path(__file__).resolve().parents[3]
-DEFAULT_BINARY = REPO_ROOT / "target" / "release" / "vector-search-bench"
-
-METRIC_NAMES = [
-    "reconstruction NMSE mean",
-    "reconstruction NMSE median",
-    "reconstruction NMSE max",
-    "decoded cosine sqerr mean",
-    "decoded cosine sqerr median",
-    "decoded cosine sqerr max",
-]
-
-
-@dataclass(frozen=True)
-class DatasetTarget:
-    """One dataset to sweep, with the layout the bench should use for it."""
-
-    name: str
-    layout: str | None  # `None` means let the bench auto-pick.
-
-
-@dataclass
-class Run:
-    target: DatasetTarget
-    dim: int
-    bits: int
-    values: dict[str, float]
-
-    @property
-    def dataset(self) -> str:
-        return self.target.name
-
-
-DIM_RE = re.compile(r"dim=(\d+)")
-
-
-def parse_dataset_arg(spec: str, default_layout: str | None) -> DatasetTarget:
-    """Split a `name[:layout]` CLI value. `default_layout` fills in when no `:` is given."""
-    if ":" in spec:
-        name, layout = spec.split(":", 1)
-        return DatasetTarget(name=name, layout=layout or None)
-    return DatasetTarget(name=spec, layout=default_layout)
-
-
-def parse_dim(stdout: str) -> int:
-    """Pull `dim=N` out of the `## ...` header line."""
-    match = DIM_RE.search(stdout)
-    if not match:
-        raise RuntimeError(f"could not find dim=N in header:\n{stdout}")
-    return int(match.group(1))
-
-
-def parse_table(stdout: str) -> dict[str, float]:
-    """Pull `metric -> value` rows out of the tabled stdout."""
-    row_re = re.compile(r"│\s*(.+?)\s*│\s*([^│]+?)\s*│")
-    values: dict[str, float] = {}
-    for line in stdout.splitlines():
-        match = row_re.match(line)
-        if not match:
-            continue
-        metric, value = match.group(1).strip(), match.group(2).strip()
-        if metric in METRIC_NAMES:
-            values[metric] = float(value)
-    missing = [m for m in METRIC_NAMES if m not in values]
-    if missing:
-        raise RuntimeError(f"could not parse metrics {missing} from:\n{stdout}")
-    return values
-
-
-def run_one(
-    binary: Path,
-    target: DatasetTarget,
-    bits: int,
-    samples: int,
-    seed: int,
-    rounds: int,
-) -> Run:
-    cmd = [
-        str(binary),
-        "distortion",
-        "--dataset",
-        target.name,
-        "--bits",
-        str(bits),
-        "--samples",
-        str(samples),
-        "--seed",
-        str(seed),
-        "--rounds",
-        str(rounds),
-    ]
-    if target.layout:
-        cmd.extend(["--layout", target.layout])
-    layout_tag = f" layout={target.layout}" if target.layout else ""
-    print(f"  running {target.name}{layout_tag} @ bits={bits} ...", file=sys.stderr)
-    result = subprocess.run(cmd, capture_output=True, text=True, check=True)
-    return Run(
-        target=target,
-        dim=parse_dim(result.stdout),
-        bits=bits,
-        values=parse_table(result.stdout),
-    )
-
-
-# Refined small-b values from `main.tex` line 273-274 ("for b = 1, 2, 3, 4 we have
-# D_mse approx 0.36, 0.117, 0.03, 0.009"). Tighter than the general sqrt(3)*pi/2 * 4^(-b)
-# upper bound, which is what we fall back to for b >= 5.
-_NMSE_UPPER_REFINED = {1: 0.36, 2: 0.117, 3: 0.03, 4: 0.009}
-
-
-def nmse_bound_stage1(bits: int) -> float:
-    """Paper's Stage-1 unit-norm reconstruction upper bound for TurboQuant_mse.
-
-    From the Stage 1 theorem (`main.tex`, line 272): for a unit-norm vector `x` quantized
-    to `b` bits per coordinate, `E[||x - x'||^2] <= (sqrt(3)*pi/2) * 4^(-b)`. TurboQuant
-    internally normalizes each input before quantizing, so the bound applies to per-row
-    NMSE = `||x - x'||^2 / ||x||^2 = ||unit(x) - unit(x')||^2` directly. For small `b`
-    (1..=4) the paper gives tighter refined values; we splice those in.
-    """
-    if bits in _NMSE_UPPER_REFINED:
-        return _NMSE_UPPER_REFINED[bits]
-    return (math.sqrt(3.0) * math.pi / 2.0) / (4.0**bits)
-
-
-def nmse_lower_bound(bits: int) -> float:
-    """Paper's Shannon lower bound on Stage-1 unit-norm reconstruction.
-
-    From `main.tex` line 297: `D_mse(Q) >= 1/4^b` for any randomized `b`-bit quantizer.
-    Independent of dimension; applies to NMSE for the same reason as the upper bound.
-    """
-    return 1.0 / (4.0**bits)
-
-
-def compression_ratio(bits: int, dim: int) -> float:
-    """Theoretical TurboQuant compression ratio vs f32 storage.
-
-    Per the `vortex_tensor::encodings::turboquant` module docs, each vector is stored
-    as `padded_dim * bits / 8` bytes of quantized codes plus one f32 stored norm
-    (4 bytes), where `padded_dim` is the next power of two at least `dim`. The ratio is
-    nonlinear in `bits` because of POT padding and the per-vector norm overhead.
-    """
-    padded_dim = 1 << (dim - 1).bit_length() if dim > 1 else 1
-    per_vector_bytes = padded_dim * bits / 8.0 + 4.0
-    original_bytes = dim * 4.0
-    return original_bytes / per_vector_bytes
-
-
-def cosine_sqerr_lower_bound(bits: int, dim: int) -> float:
-    """Paper's Shannon lower bound on Stage-2 squared inner-product distortion.
-
-    From `main.tex` line 298: `D_prod(Q) >= ||y||^2 / d * 1/4^b` for any randomized
-    `b`-bit quantizer. With unit probes (`||y||^2 = 1`) this is `1 / (d * 4^b)`.
-    """
-    return 1.0 / (dim * (4.0**bits))
-
-
-DATASET_PALETTE = [
-    "#1f77b4",  # blue
-    "#d62728",  # red
-    "#2ca02c",  # green
-    "#9467bd",  # purple
-    "#ff7f0e",  # orange
-    "#17becf",  # teal
-    "#e377c2",  # pink
-    "#8c564b",  # brown
-    "#7f7f7f",  # grey
-    "#bcbd22",  # olive
-]
-
-STAT_STYLES = [
-    # (metric_suffix, label, linestyle, linewidth, marker)
-    ("mean", "mean", "-", 2.4, "o"),
-    ("max", "max", ":", 1.4, None),
-]
-
-
-def plot(runs: list[Run], args: argparse.Namespace) -> None:
-    by_dataset: dict[str, list[Run]] = {}
-    for r in runs:
-        by_dataset.setdefault(r.dataset, []).append(r)
-    for ds_runs in by_dataset.values():
-        ds_runs.sort(key=lambda r: r.bits)
-
-    plt.rcParams.update(
-        {
-            "font.size": 11,
-            "axes.titlesize": 13,
-            "axes.titleweight": "semibold",
-            "axes.labelsize": 11,
-            "axes.spines.top": False,
-            "axes.spines.right": False,
-            "axes.grid": True,
-            "grid.alpha": 0.25,
-            "grid.linewidth": 0.6,
-            "legend.frameon": False,
-        }
-    )
-
-    # GridSpec with a dedicated bottom strip for the caption so the long text gets a real
-    # subplot rect: no clipping by `bbox_inches`, no overlap with axis labels, no reliance
-    # on matplotlib's `wrap=True` heuristic. Plot row gets the lion's share so the bottom
-    # caption strip doesn't dominate visually; legends are anchored above the axes via
-    # `bbox_to_anchor` (see `add_legends`), and constrained_layout reserves space for them
-    # inside the plot row.
-    fig = plt.figure(figsize=(22, 9.5), constrained_layout=True)
-    gs = fig.add_gridspec(2, 3, height_ratios=[12, 1])
-    axes = [fig.add_subplot(gs[0, i]) for i in range(3)]
-    caption_ax = fig.add_subplot(gs[1, :])
-    caption_ax.axis("off")
-    fig.suptitle(
-        f"TurboQuant distortion vs bits per coordinate"
-        f"     (samples={args.samples:,}, seed={args.seed}, rounds={args.rounds})",
-        fontsize=14,
-        fontweight="semibold",
-    )
-
-    dataset_colors = {ds: DATASET_PALETTE[i % len(DATASET_PALETTE)] for i, ds in enumerate(by_dataset)}
-    dataset_dims = {ds: ds_runs[0].dim for ds, ds_runs in by_dataset.items()}
-
-    plot_panel(
-        axes[0],
-        by_dataset,
-        dataset_colors,
-        metric_prefix="reconstruction NMSE",
-        title=r"Reconstruction NMSE   (per vector, $\|x - x^\prime\|^2 / \|x\|^2$)",
-        ylabel=r"$\|x - x^\prime\|^2 / \|x\|^2$",
-    )
-    bits_axis = sorted({r.bits for r in runs})
-    axes[0].plot(
-        bits_axis,
-        [nmse_bound_stage1(b) for b in bits_axis],
-        color="#222222",
-        linestyle=(0, (4, 2, 1, 2)),
-        linewidth=1.6,
-        zorder=0,
-    )
-    axes[0].plot(
-        bits_axis,
-        [nmse_lower_bound(b) for b in bits_axis],
-        color="#222222",
-        linestyle=(0, (1, 2)),
-        linewidth=1.4,
-        zorder=0,
-    )
-
-    plot_panel(
-        axes[1],
-        by_dataset,
-        dataset_colors,
-        metric_prefix="decoded cosine sqerr",
-        title=r"Squared cosine error   $(\cos(y_i, x_i) - \cos(y_i, x_i^\prime))^2$",
-        ylabel="squared error",
-    )
-    for dataset, ds_runs in by_dataset.items():
-        color = dataset_colors[dataset]
-        d = ds_runs[0].dim
-        bits = sorted({r.bits for r in ds_runs})
-        axes[1].plot(
-            bits,
-            [cosine_sqerr_lower_bound(b, d) for b in bits],
-            color=color,
-            linestyle=(0, (1, 2)),
-            linewidth=1.0,
-            alpha=0.5,
-            zorder=0,
-        )
-
-    plot_compression_panel(axes[2], by_dataset, dataset_colors)
-
-    add_legends(fig, axes, dataset_colors, dataset_dims)
-    caption_ax.text(
-        0.5,
-        1.0,
-        "NMSE upper bound uses the paper's refined small-b values for b<=4 and the "
-        "smooth sqrt(3)*pi/2 * 4^(-b) general formula for b>=5.  Lower bounds are the "
-        "Shannon information-theoretic floor for any randomized b-bit quantizer.  "
-        "Vortex ships TurboQuant Stage 1 only, so no Stage-2 inner-product upper "
-        "bound is drawn on the cosine panel.  Probe vectors y_i are sampled iid "
-        "uniform on the unit sphere.  Compression ratio is theoretical "
-        "(padded_dim * bits / 8 + 4 bytes per vector), excludes per-shard centroid "
-        "tables and file metadata.",
-        ha="center",
-        va="top",
-        fontsize=9,
-        color="#555555",
-        wrap=True,
-        transform=caption_ax.transAxes,
-    )
-
-    if args.output:
-        fig.savefig(args.output, dpi=140, bbox_inches="tight")
-        print(f"saved {args.output}", file=sys.stderr)
-    else:
-        plt.show()
-
-
-def plot_panel(
-    ax,
-    by_dataset: dict[str, list[Run]],
-    dataset_colors: dict[str, str],
-    metric_prefix: str,
-    title: str,
-    ylabel: str,
-) -> None:
-    for dataset, ds_runs in by_dataset.items():
-        color = dataset_colors[dataset]
-        bits = [r.bits for r in ds_runs]
-        for stat_key, _label, linestyle, linewidth, marker in STAT_STYLES:
-            metric = f"{metric_prefix} {stat_key}"
-            ys = [r.values[metric] for r in ds_runs]
-            ax.plot(
-                bits,
-                ys,
-                color=color,
-                linestyle=linestyle,
-                linewidth=linewidth,
-                marker=marker,
-                markersize=6,
-                markerfacecolor=color,
-                markeredgecolor="white",
-                markeredgewidth=0.8,
-                alpha=0.95 if marker else 0.75,
-            )
-    ax.set_yscale("log")
-    ax.set_xlabel("bits per coordinate")
-    ax.set_ylabel(ylabel)
-    ax.set_title(title)
-    ax.xaxis.set_major_locator(MaxNLocator(integer=True))
-    ax.grid(True, which="major", linewidth=0.7, alpha=0.45)
-    ax.grid(True, which="minor", linewidth=0.4, alpha=0.22)
-    ax.minorticks_on()
-    # Only the integer bit-widths should get an x-axis line; suppress the in-between
-    # minor ticks that `minorticks_on()` adds (the y-axis minors stay - they're useful
-    # on the log scale).
-    ax.xaxis.set_minor_locator(NullLocator())
-
-
-def plot_compression_panel(
-    ax,
-    by_dataset: dict[str, list[Run]],
-    dataset_colors: dict[str, str],
-) -> None:
-    bits_axis = sorted({r.bits for runs in by_dataset.values() for r in runs})
-    for dataset, ds_runs in by_dataset.items():
-        color = dataset_colors[dataset]
-        d = ds_runs[0].dim
-        padded = 1 << (d - 1).bit_length() if d > 1 else 1
-        suffix = f"  (padded {padded})" if padded != d else "  (no padding)"
-        ax.plot(
-            bits_axis,
-            [compression_ratio(b, d) for b in bits_axis],
-            color=color,
-            linestyle="-",
-            linewidth=2.4,
-            marker="o",
-            markersize=6,
-            markerfacecolor=color,
-            markeredgecolor="white",
-            markeredgewidth=0.8,
-            label=f"{dataset}{suffix}",
-        )
-    ax.set_xlabel("bits per coordinate")
-    ax.set_ylabel(r"ratio vs f32  (=  $4d \,/\, (\mathrm{padded}\!\cdot\! b/8 + 4)$)")
-    ax.set_title("Compression ratio   (theoretical)")
-    ax.xaxis.set_major_locator(MaxNLocator(integer=True))
-    ax.grid(True, which="major", linewidth=0.7, alpha=0.45)
-    ax.grid(True, which="minor", linewidth=0.4, alpha=0.22)
-    ax.minorticks_on()
-    ax.xaxis.set_minor_locator(NullLocator())
-    ax.legend(
-        title="dataset",
-        loc="lower center",
-        bbox_to_anchor=(0.5, 1.02),
-        ncol=2,
-        fontsize=9,
-        title_fontsize=10,
-    )
-
-
-def add_legends(
-    fig,
-    axes,
-    dataset_colors: dict[str, str],
-    dataset_dims: dict[str, int],
-) -> None:
-    dataset_handles = [
-        Line2D(
-            [],
-            [],
-            color=color,
-            linewidth=2.4,
-            marker="o",
-            markersize=6,
-            markerfacecolor=color,
-            markeredgecolor="white",
-            markeredgewidth=0.8,
-            label=f"{dataset}  (d = {dataset_dims[dataset]})",
-        )
-        for dataset, color in dataset_colors.items()
-    ]
-    stat_handles = [
-        Line2D(
-            [],
-            [],
-            color="#333333",
-            linestyle=linestyle,
-            linewidth=linewidth,
-            marker=marker,
-            markersize=6 if marker else 0,
-            markerfacecolor="#333333",
-            markeredgecolor="white",
-            markeredgewidth=0.8,
-            label=label,
-        )
-        for _, label, linestyle, linewidth, marker in STAT_STYLES
-    ]
-    nmse_upper_handle = Line2D(
-        [],
-        [],
-        color="#222222",
-        linestyle=(0, (4, 2, 1, 2)),
-        linewidth=1.6,
-        label=(
-            r"upper bound:  "
-            r"$D_{\mathrm{mse}} \leq \frac{\sqrt{3}\,\pi}{2}\, 4^{-b}$  (refined for $b\!\leq\!4$)"
-        ),
-    )
-    nmse_lower_handle = Line2D(
-        [],
-        [],
-        color="#222222",
-        linestyle=(0, (1, 2)),
-        linewidth=1.4,
-        label=r"lower bound:  $D_{\mathrm{mse}} \geq 4^{-b}$",
-    )
-    cosine_lower_handle = Line2D(
-        [],
-        [],
-        color="#444444",
-        linestyle=(0, (1, 2)),
-        linewidth=1.0,
-        alpha=0.5,
-        label=r"lower bound:  $D_{\mathrm{prod}} \geq \frac{1}{d}\, 4^{-b}$",
-    )
-
-    axes[0].legend(
-        handles=dataset_handles + [nmse_upper_handle, nmse_lower_handle],
-        title="dataset / bound",
-        loc="lower center",
-        bbox_to_anchor=(0.5, 1.02),
-        ncol=2,
-        fontsize=10,
-        title_fontsize=10,
-    )
-    axes[1].legend(
-        handles=stat_handles + [cosine_lower_handle],
-        title="statistic / bound",
-        loc="lower center",
-        bbox_to_anchor=(0.5, 1.02),
-        ncol=3,
-        fontsize=10,
-        title_fontsize=10,
-    )
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
-    parser.add_argument(
-        "--dataset",
-        action="append",
-        required=True,
-        help=(
-            "Dataset to sweep (repeat to compare multiple). Optionally suffix "
-            "`:layout` to pin a specific train layout for that dataset, e.g. "
-            "`--dataset cohere-small-100k:single`. If omitted, the bench picks "
-            "the dataset's only layout, or errors if there are several."
-        ),
-    )
-    parser.add_argument(
-        "--layout",
-        default=None,
-        help=("Default train layout applied to any `--dataset` entry that doesn't pin its own with `:layout`."),
-    )
-    parser.add_argument("--samples", type=int, default=65536)
-    parser.add_argument(
-        "--bits",
-        type=int,
-        nargs="+",
-        default=[1, 2, 3, 4, 5, 6, 7, 8],
-        help="Bit widths to sweep (default: 1..=8).",
-    )
-    parser.add_argument("--seed", type=int, default=42)
-    parser.add_argument("--rounds", type=int, default=3)
-    parser.add_argument(
-        "--binary",
-        type=Path,
-        default=DEFAULT_BINARY,
-        help=f"Path to vector-search-bench (default: {DEFAULT_BINARY}).",
-    )
-    parser.add_argument(
-        "--output",
-        type=Path,
-        default=None,
-        help="If set, save the chart to this path instead of opening a window.",
-    )
-    args = parser.parse_args()
-
-    print("building vector-search-bench (release) ...", file=sys.stderr)
-    subprocess.run(
-        ["cargo", "build", "-p", "vector-search-bench", "--release"],
-        cwd=REPO_ROOT,
-        check=True,
-    )
-
-    if not args.binary.exists():
-        sys.exit(f"binary not found at {args.binary} after build")
-
-    targets = [parse_dataset_arg(spec, args.layout) for spec in args.dataset]
-
-    runs: list[Run] = []
-    for target in targets:
-        layout_tag = f" (layout={target.layout})" if target.layout else ""
-        print(
-            f"sweeping {target.name}{layout_tag} over bits {args.bits} ...",
-            file=sys.stderr,
-        )
-        for bits in args.bits:
-            runs.append(
-                run_one(
-                    args.binary,
-                    target,
-                    bits,
-                    args.samples,
-                    args.seed,
-                    args.rounds,
-                )
-            )
-
-    print_summary(runs)
-    plot(runs, args)
-
-
-def print_summary(runs: list[Run]) -> None:
-    print()
-    print("Summary (one row per (dataset, bits)):")
-    header = ["dataset", "dim", "bits"] + METRIC_NAMES
-    widths = [max(len(h), 14) for h in header]
-    print("  " + "  ".join(h.ljust(w) for h, w in zip(header, widths)))
-    for r in runs:
-        cells = [r.dataset, str(r.dim), str(r.bits)] + [f"{r.values[m]:.3e}" for m in METRIC_NAMES]
-        print("  " + "  ".join(c.ljust(w) for c, w in zip(cells, widths)))
-
-
-if __name__ == "__main__":
-    main()
diff --git a/benchmarks/vector-search-bench/src/compression.rs b/benchmarks/vector-search-bench/src/compression.rs
deleted file mode 100644
index 9b40cb15544..00000000000
--- a/benchmarks/vector-search-bench/src/compression.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Vector compression flavors exercised by the benchmark.
-//!
-//! Each [`VectorFlavor`] variant maps to a [`vortex::file::WriteStrategyBuilder`] configuration
-//! applied to the same input data.
-//!
-//! The benchmark writes one `.vortex` file per flavor per data file, then scans them all with the
-//! same query so the comparison is apples-to-apples with the Parquet files.
-
-use clap::ValueEnum;
-use vortex::array::ArrayId;
-use vortex::array::scalar_fn::ScalarFnVTable;
-use vortex::file::ALLOWED_ENCODINGS;
-use vortex::file::VortexWriteOptions;
-use vortex::file::WriteOptionsSessionExt;
-use vortex::file::WriteStrategyBuilder;
-use vortex::session::VortexSession;
-use vortex::utils::aliases::hash_set::HashSet;
-use vortex_bench::Format;
-use vortex_btrblocks::BtrBlocksCompressorBuilder;
-use vortex_tensor::encodings::l2_denorm::L2DenormScheme;
-use vortex_tensor::scalar_fns::l2_denorm::L2Denorm;
-use vortex_tensor::scalar_fns::sorf_transform::SorfTransform;
-
-/// Every [`VectorFlavor`] variant in CLI-help order.
-pub const ALL_VECTOR_FLAVORS: &[VectorFlavor] =
-    &[VectorFlavor::Uncompressed, VectorFlavor::TurboQuant];
-
-/// One write-side compression configuration we measure.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, ValueEnum)]
-pub enum VectorFlavor {
-    /// `BtrBlocksCompressorBuilder::empty()`
-    #[clap(name = "vortex-uncompressed")]
-    Uncompressed,
-    /// `BtrBlocksCompressorBuilder::default().with_turboquant()`.
-    #[clap(name = "vortex-turboquant")]
-    TurboQuant,
-    // TODO(connor): We will want to add `Default` here which is just the default compressor.
-}
-
-impl VectorFlavor {
-    /// Stable kebab-cased label used in CLI args and metric names.
-    pub fn label(&self) -> &'static str {
-        match self {
-            VectorFlavor::Uncompressed => "vortex-uncompressed",
-            VectorFlavor::TurboQuant => "vortex-turboquant",
-        }
-    }
-
-    /// The `target.format` value emitted on measurements for this flavor. Both flavors produce
-    /// `.vortex` files, so the compression label carries the flavor split.
-    pub fn as_format(&self) -> Format {
-        match self {
-            VectorFlavor::Uncompressed => Format::OnDiskVortex,
-            VectorFlavor::TurboQuant => Format::OnDiskVortex,
-        }
-    }
-
-    /// Subdirectory name under the per-dataset cache root used to store this flavor's `.vortex`
-    /// files.
-    pub fn dir_name(&self) -> &'static str {
-        match self {
-            VectorFlavor::Uncompressed => "vortex-uncompressed",
-            VectorFlavor::TurboQuant => "vortex-turboquant",
-        }
-    }
-
-    /// Build the [`vortex::file::WriteStrategyBuilder`]-backed write options for this flavor.
-    ///
-    /// TurboQuant produces `L2Denorm(SorfTransform(...))` which the default file
-    /// `ALLOWED_ENCODINGS` set rejects on normalization — we extend the allow-list with the two
-    /// scalar-fn array IDs the scheme actually emits.
-    pub fn create_write_options(&self, session: &VortexSession) -> VortexWriteOptions {
-        let strategy = match self {
-            VectorFlavor::Uncompressed => {
-                // Even though this is uncompressed, we still want to denormalize the data first so
-                // that the results are fair.
-                let compressor = BtrBlocksCompressorBuilder::empty()
-                    .with_new_scheme(&L2DenormScheme)
-                    .build();
-
-                let mut allowed: HashSet<ArrayId> = ALLOWED_ENCODINGS.clone();
-                allowed.insert(L2Denorm.id());
-
-                WriteStrategyBuilder::default()
-                    .with_compressor(compressor)
-                    .with_allow_encodings(allowed)
-                    .build()
-            }
-            VectorFlavor::TurboQuant => {
-                let compressor = BtrBlocksCompressorBuilder::default()
-                    .with_turboquant()
-                    .build();
-
-                let mut allowed: HashSet<ArrayId> = ALLOWED_ENCODINGS.clone();
-                allowed.insert(L2Denorm.id());
-                allowed.insert(SorfTransform.id());
-
-                WriteStrategyBuilder::default()
-                    .with_compressor(compressor)
-                    .with_allow_encodings(allowed)
-                    .build()
-            }
-        };
-
-        session.write_options().with_strategy(strategy)
-    }
-}
diff --git a/benchmarks/vector-search-bench/src/display.rs b/benchmarks/vector-search-bench/src/display.rs
deleted file mode 100644
index a74eec46b01..00000000000
--- a/benchmarks/vector-search-bench/src/display.rs
+++ /dev/null
@@ -1,133 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Local table renderer for the vector-search benchmark.
-//!
-//! Groups columns by **flavor** (`vortex-uncompressed`, `vortex-turboquant`) rather than by
-//! [`vortex_bench::Format`], because the two Vortex flavors share a single
-//! `Format::OnDiskVortex`/`Format::VortexLossy` pair and the generic
-//! [`vortex_bench::display::render_table`] groups by Format. Local renderer keeps the
-//! column-per-flavor invariant intact without introducing a new global Format value.
-//!
-//! Output rows:
-//!
-//! ```text
-//!   Metric             | vortex-uncompressed | vortex-turboquant
-//!   ------------------ + ------------------- + -----------------
-//!   scan wall (mean)   |              485 ms |            212 ms
-//!   scan wall (median) |              490 ms |            215 ms
-//!   matches            |                  42 |                39
-//!   rows scanned       |          10,000,000 |        10,000,000
-//!   bytes scanned      |             30.5 GB |           7.62 GB
-//!   rows / sec         |              5.2e6  |           1.2e7
-//! ```
-
-use std::io::Write;
-
-use anyhow::Result;
-use tabled::settings::Style;
-
-use crate::compression::VectorFlavor;
-use crate::prepare::CompressedVortexDataset;
-use crate::scan::ScanTiming;
-
-/// Final column-per-flavor row set for one dataset.
-pub struct DatasetReport<'a> {
-    pub dataset_name: &'a str,
-    pub vortex_results: &'a [(VectorFlavor, &'a CompressedVortexDataset, &'a ScanTiming)],
-}
-
-/// Render the full report into the given writer as a tabled table.
-pub fn render(report: &DatasetReport<'_>, writer: &mut dyn Write) -> Result<()> {
-    let mut headers: Vec<String> = vec!["metric".to_owned()];
-    for &(flavor, ..) in report.vortex_results {
-        headers.push(flavor.label().to_owned());
-    }
-
-    let rows: Vec<Vec<String>> = vec![
-        make_row("scan wall (mean)", report, |_, _, scan| {
-            format_duration(scan.mean)
-        }),
-        make_row("scan wall (median)", report, |_, _, scan| {
-            format_duration(scan.median)
-        }),
-        make_row("matches", report, |_, _, scan| scan.matches.to_string()),
-        make_row("rows scanned", report, |_, _, scan| {
-            scan.rows_scanned.to_string()
-        }),
-        make_row("bytes scanned", report, |_, _, scan| {
-            format_bytes(scan.bytes_scanned)
-        }),
-        make_row("rows / sec", report, |_, _, scan| {
-            format_throughput_rows(scan.rows_scanned, scan.mean)
-        }),
-    ];
-
-    writeln!(writer, "## {}", report.dataset_name)?;
-    let mut builder = tabled::builder::Builder::new();
-    builder.push_record(headers);
-    for row in rows {
-        builder.push_record(row);
-    }
-    let mut table = builder.build();
-    table.with(Style::modern());
-    writeln!(writer, "{table}")?;
-    Ok(())
-}
-
-fn make_row<F>(metric: &str, report: &DatasetReport<'_>, vortex_cell: F) -> Vec<String>
-where
-    F: Fn(VectorFlavor, &CompressedVortexDataset, &ScanTiming) -> String,
-{
-    let mut row = vec![metric.to_owned()];
-    for &(flavor, prep, scan) in report.vortex_results {
-        row.push(vortex_cell(flavor, prep, scan));
-    }
-    row
-}
-
-fn format_duration(d: std::time::Duration) -> String {
-    let secs = d.as_secs_f64();
-    if secs >= 1.0 {
-        format!("{secs:.2} s")
-    } else if secs >= 1e-3 {
-        format!("{:.1} ms", secs * 1e3)
-    } else {
-        format!("{:.1} µs", secs * 1e6)
-    }
-}
-
-fn format_bytes(bytes: u64) -> String {
-    const UNITS: &[&str] = &["B", "KiB", "MiB", "GiB", "TiB"];
-    let mut value = bytes as f64;
-    let mut unit = UNITS[0];
-    for next in &UNITS[1..] {
-        if value < 1024.0 {
-            break;
-        }
-        value /= 1024.0;
-        unit = next;
-    }
-    if unit == "B" {
-        format!("{bytes} B")
-    } else {
-        format!("{value:.2} {unit}")
-    }
-}
-
-fn format_throughput_rows(rows: u64, wall: std::time::Duration) -> String {
-    let secs = wall.as_secs_f64();
-    if secs <= 0.0 {
-        return "—".to_owned();
-    }
-    let rps = rows as f64 / secs;
-    if rps >= 1e9 {
-        format!("{:.2}G", rps / 1e9)
-    } else if rps >= 1e6 {
-        format!("{:.2}M", rps / 1e6)
-    } else if rps >= 1e3 {
-        format!("{:.2}K", rps / 1e3)
-    } else {
-        format!("{rps:.0}")
-    }
-}
diff --git a/benchmarks/vector-search-bench/src/distortion.rs b/benchmarks/vector-search-bench/src/distortion.rs
deleted file mode 100644
index 7a05410522e..00000000000
--- a/benchmarks/vector-search-bench/src/distortion.rs
+++ /dev/null
@@ -1,370 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! TurboQuant distortion measurement on real vector datasets.
-//!
-//! Reports the normalized mean square error (`||x - x'||^2 / ||x||^2`) and the squared
-//! cosine-similarity error (`(cos(y_i, x_i) - cos(y_i, x'_i))^2`) against a set of independently
-//! sampled unit-norm probe vectors `y_i`, after a full encode and decode roundtrip through the
-//! [`vortex_tensor::encodings::turboquant`] scheme.
-//!
-//! NMSE rather than raw SSE because TurboQuant internally normalizes each input to unit
-//! norm before quantizing (storing `||x||` separately), so the paper's Stage-1 bound
-//! `E[||unit(x) - unit(x')||^2] <= (sqrt(3) * pi / 2) * 4^(-b)` applies to NMSE directly;
-//! raw `||x - x'||^2` sits at `||x||^2` times that bound and isn't comparable across rows.
-
-use std::io::Write;
-
-use anyhow::Context;
-use anyhow::Result;
-use anyhow::bail;
-use rand::SeedableRng;
-use rand::rngs::StdRng;
-use rand_distr::Distribution;
-use rand_distr::Normal;
-use tabled::settings::Style;
-use vortex::array::ArrayRef;
-use vortex::array::ExecutionCtx;
-use vortex::array::IntoArray;
-use vortex::array::VortexSessionExecute;
-use vortex::array::arrays::ExtensionArray;
-use vortex::array::arrays::FixedSizeListArray;
-use vortex::array::arrays::PrimitiveArray;
-use vortex::array::arrays::Struct;
-use vortex::array::arrays::StructArray;
-use vortex::array::arrays::extension::ExtensionArrayExt;
-use vortex::array::arrays::fixed_size_list::FixedSizeListArrayExt;
-use vortex::array::arrays::struct_::StructArrayExt;
-use vortex::error::VortexExpect;
-use vortex_bench::conversions::parquet_to_vortex_chunks;
-use vortex_bench::vector_dataset;
-use vortex_bench::vector_dataset::TrainLayout;
-use vortex_bench::vector_dataset::VectorDataset;
-use vortex_tensor::encodings::turboquant::TurboQuantConfig;
-use vortex_tensor::encodings::turboquant::turboquant_encode;
-
-use crate::SESSION;
-use crate::ingest::transform_chunk;
-
-/// Inputs to a distortion run.
-#[derive(Debug, Clone)]
-pub struct DistortionConfig {
-    /// Dataset to load vectors from.
-    pub dataset: VectorDataset,
-    /// Train-split layout (used to locate the local parquet shards).
-    pub layout: TrainLayout,
-    /// Bits per quantized coordinate.
-    pub bits: u8,
-    /// Seed for the SORF rotation.
-    pub seed: u64,
-    /// Number of sign-diagonal plus Walsh-Hadamard rounds in the SORF transform.
-    pub rounds: u8,
-    /// Number of base vectors to sample from the first train shard.
-    pub samples: usize,
-}
-
-/// Mean, median, and max of a sample of distortion measurements.
-#[derive(Debug, Clone)]
-pub struct DistortionStats {
-    /// Arithmetic mean.
-    pub mean: f32,
-    /// Median (mid element after a partial sort).
-    pub median: f32,
-    /// Maximum.
-    pub max: f32,
-}
-
-/// Per-dataset distortion report ready to render as markdown.
-#[derive(Debug, Clone)]
-pub struct DistortionReport {
-    /// Dataset the vectors came from.
-    pub dataset: VectorDataset,
-    /// Train-split layout used to locate the shard.
-    pub layout: TrainLayout,
-    /// Vector dimensionality.
-    pub dim: u32,
-    /// Bits per quantized coordinate.
-    pub bits: u8,
-    /// Seed for the SORF rotation.
-    pub seed: u64,
-    /// Number of SORF rounds.
-    pub rounds: u8,
-    /// Number of base vectors sampled.
-    pub samples: usize,
-    /// Normalized squared reconstruction error per row, `||x - x'||^2 / ||x||^2`.
-    pub reconstruction: DistortionStats,
-    /// Squared cosine-similarity error per row against a random unit-norm probe `y_i`,
-    /// `(cos(y_i, x_i) - cos(y_i, x'_i))^2`.
-    pub decoded_cosine: DistortionStats,
-}
-
-/// Compute reconstruction error and cosine-similarity error for a TurboQuant roundtrip.
-pub async fn run_distortion(config: &DistortionConfig) -> Result<DistortionReport> {
-    let dataset = config.dataset;
-    let layout = config.layout;
-
-    let paths = vector_dataset::download(dataset, layout)
-        .await
-        .with_context(|| format!("download {}", dataset.name()))?;
-    let train_path = paths
-        .train_files
-        .first()
-        .with_context(|| format!("dataset {} has no train shards", dataset.name()))?
-        .clone();
-
-    let mut ctx = SESSION.create_execution_ctx();
-
-    let chunked = parquet_to_vortex_chunks(train_path).await?;
-    let struct_array: StructArray = chunked.into_array().execute(&mut ctx)?;
-    let transformed = transform_chunk(struct_array.into_array(), &mut ctx)?;
-    let emb_full = transformed
-        .as_opt::<Struct>()
-        .with_context(|| {
-            format!(
-                "transform_chunk did not return a Struct, got {}",
-                transformed.dtype()
-            )
-        })?
-        .unmasked_field_by_name("emb")
-        .context("transformed chunk missing `emb` field")?
-        .clone();
-
-    let n = config.samples.min(emb_full.len());
-    if n == 0 {
-        bail!(
-            "distortion: need at least one sampled vector, got 0 (dataset {})",
-            dataset.name(),
-        );
-    }
-    let emb = emb_full.slice(0..n)?;
-
-    let original = extract_flat_f32(&emb, &mut ctx)?;
-    let dim = pairs_per_row(&original, n)?;
-
-    let tq_config = TurboQuantConfig {
-        bit_width: config.bits,
-        seed: config.seed,
-        num_rounds: config.rounds,
-    };
-    let encoded = turboquant_encode(emb, &tq_config, &mut ctx)?;
-    let decoded_ext: ExtensionArray = encoded.execute(&mut ctx)?;
-    let decoded = decoded_ext.into_array();
-    let decoded_flat = extract_flat_f32(&decoded, &mut ctx)?;
-
-    let reconstruction = stats(&reconstruction_nmse(&original, &decoded_flat, dim, n));
-
-    // Sample independent unit-norm probe vectors `y_i` (one per row). The TurboQuant Stage-2
-    // bound `E[(<y, x> - <y, x'>)^2] <= sqrt(3) * pi^2 / d * 4^(-b)` holds for any fixed `y`,
-    // so drawing `y` from the unit sphere is a reasonable empirical sweep.
-    let probes = random_unit_vectors(n, dim, config.seed)?;
-    let decoded_cosine = stats(&squared_cosine_errors(
-        &original,
-        &decoded_flat,
-        &probes,
-        dim,
-        n,
-    ));
-
-    Ok(DistortionReport {
-        dataset,
-        layout,
-        dim: u32::try_from(dim).context("dim must fit in u32")?,
-        bits: config.bits,
-        seed: config.seed,
-        rounds: config.rounds,
-        samples: n,
-        reconstruction,
-        decoded_cosine,
-    })
-}
-
-/// Extract a flat `f32` slice from a `Vector<f32, dim>` extension array.
-fn extract_flat_f32(array: &ArrayRef, ctx: &mut ExecutionCtx) -> Result<Vec<f32>> {
-    let ext: ExtensionArray = array.clone().execute(ctx)?;
-    let fsl: FixedSizeListArray = ext.storage_array().clone().execute(ctx)?;
-    let elements: PrimitiveArray = fsl.elements().clone().execute(ctx)?;
-    Ok(elements.as_slice::<f32>().to_vec())
-}
-
-fn pairs_per_row(flat: &[f32], num_rows: usize) -> Result<usize> {
-    if num_rows == 0 {
-        bail!("distortion: cannot derive dim from zero rows");
-    }
-    if !flat.len().is_multiple_of(num_rows) {
-        bail!(
-            "distortion: flat element count {} not divisible by row count {num_rows}",
-            flat.len(),
-        );
-    }
-    Ok(flat.len() / num_rows)
-}
-
-/// Normalized squared reconstruction error per row, `||x - x'||^2 / ||x||^2`. Zero-norm
-/// rows are dropped from the sample because NMSE is undefined when `||x|| = 0`, and our
-/// vector datasets are not expected to contain zero vectors.
-fn reconstruction_nmse(
-    original: &[f32],
-    reconstructed: &[f32],
-    dim: usize,
-    num_rows: usize,
-) -> Vec<f32> {
-    (0..num_rows)
-        .filter_map(|row| {
-            let start = row * dim;
-            let end = start + dim;
-            let orig = &original[start..end];
-            let recon = &reconstructed[start..end];
-            let norm_sq: f32 = orig.iter().map(|&v| v * v).sum();
-            if norm_sq == 0.0 {
-                return None;
-            }
-            let err_sq: f32 = orig
-                .iter()
-                .zip(recon.iter())
-                .map(|(&a, &b)| (a - b) * (a - b))
-                .sum();
-            Some(err_sq / norm_sq)
-        })
-        .collect()
-}
-
-/// Sample `num_rows` independent `dim`-D vectors with standard-normal entries and normalize each
-/// row to unit L2 norm. Used as probe vectors `y_i` for the squared cosine-similarity error.
-fn random_unit_vectors(num_rows: usize, dim: usize, seed: u64) -> Result<Vec<f32>> {
-    let mut rng = StdRng::seed_from_u64(seed);
-    let normal = Normal::new(0.0_f32, 1.0).context("constructing Normal(0, 1)")?;
-    let mut buf = vec![0.0_f32; num_rows * dim];
-    for row in 0..num_rows {
-        let start = row * dim;
-        let end = start + dim;
-        for v in &mut buf[start..end] {
-            *v = normal.sample(&mut rng);
-        }
-        let norm = buf[start..end].iter().map(|&v| v * v).sum::<f32>().sqrt();
-        if norm > 0.0 {
-            for v in &mut buf[start..end] {
-                *v /= norm;
-            }
-        }
-    }
-    Ok(buf)
-}
-
-/// Cosine similarity of two equal-length vectors, returning `0.0` if either has zero norm.
-/// A zero-norm decoded vector represents genuine quantizer failure, so the caller still
-/// gets a defined per-row error that reflects the lost direction.
-fn cosine(a: &[f32], b: &[f32]) -> f32 {
-    let dot: f32 = a.iter().zip(b.iter()).map(|(&x, &y)| x * y).sum();
-    let norm_a: f32 = a.iter().map(|&v| v * v).sum::<f32>().sqrt();
-    let norm_b: f32 = b.iter().map(|&v| v * v).sum::<f32>().sqrt();
-    let denom = norm_a * norm_b;
-    if denom == 0.0 { 0.0 } else { dot / denom }
-}
-
-/// Per-row squared cosine-similarity error against probe `y_i`,
-/// `(cos(y_i, x_i) - cos(y_i, x'_i))^2`. Rows whose original `x_i` has zero norm are
-/// dropped, matching [`reconstruction_nmse`].
-fn squared_cosine_errors(
-    original: &[f32],
-    reconstructed: &[f32],
-    probes: &[f32],
-    dim: usize,
-    num_rows: usize,
-) -> Vec<f32> {
-    (0..num_rows)
-        .filter_map(|row| {
-            let start = row * dim;
-            let end = start + dim;
-            let xi = &original[start..end];
-            let xi_dec = &reconstructed[start..end];
-            let yi = &probes[start..end];
-            if xi.iter().map(|&v| v * v).sum::<f32>() == 0.0 {
-                return None;
-            }
-            let diff = cosine(yi, xi) - cosine(yi, xi_dec);
-            Some(diff * diff)
-        })
-        .collect()
-}
-
-fn stats(samples: &[f32]) -> DistortionStats {
-    if samples.is_empty() {
-        return DistortionStats {
-            mean: f32::NAN,
-            median: f32::NAN,
-            max: f32::NAN,
-        };
-    }
-
-    let sum: f64 = samples.iter().map(|&v| f64::from(v)).sum();
-    #[expect(
-        clippy::cast_possible_truncation,
-        reason = "casting an f64 mean back to f32 is intentional and matches the input precision"
-    )]
-    let mean = (sum / samples.len() as f64) as f32;
-
-    let mut sorted = samples.to_vec();
-    sorted.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
-    let mid = sorted.len() / 2;
-    let median = if sorted.len() % 2 == 1 {
-        sorted[mid]
-    } else {
-        0.5 * (sorted[mid - 1] + sorted[mid])
-    };
-
-    let max = samples
-        .iter()
-        .copied()
-        .reduce(f32::max)
-        .vortex_expect("samples is non-empty per the early return above");
-
-    DistortionStats { mean, median, max }
-}
-
-impl DistortionReport {
-    /// Render the report as a markdown header line followed by a tabled table.
-    pub fn render(&self, writer: &mut dyn Write) -> Result<()> {
-        writeln!(
-            writer,
-            "## {} | dim={} | layout={} | bits={} | samples={} | seed={} | rounds={}",
-            self.dataset.name(),
-            self.dim,
-            self.layout.label(),
-            self.bits,
-            self.samples,
-            self.seed,
-            self.rounds,
-        )?;
-
-        let rows: &[(&str, f32)] = &[
-            ("reconstruction NMSE mean", self.reconstruction.mean),
-            ("reconstruction NMSE median", self.reconstruction.median),
-            ("reconstruction NMSE max", self.reconstruction.max),
-            ("decoded cosine sqerr mean", self.decoded_cosine.mean),
-            ("decoded cosine sqerr median", self.decoded_cosine.median),
-            ("decoded cosine sqerr max", self.decoded_cosine.max),
-        ];
-
-        let mut builder = tabled::builder::Builder::new();
-        builder.push_record(["metric", "value"]);
-        for &(metric, value) in rows {
-            builder.push_record([metric.to_owned(), format_metric(value)]);
-        }
-        let mut table = builder.build();
-        table.with(Style::modern());
-        writeln!(writer, "{table}")?;
-        Ok(())
-    }
-}
-
-fn format_metric(value: f32) -> String {
-    if value.is_nan() {
-        "nan".to_owned()
-    } else if value == 0.0 {
-        "0".to_owned()
-    } else if value.abs() < 1e-3 || value.abs() >= 1e4 {
-        format!("{value:.3e}")
-    } else {
-        format!("{value:.6}")
-    }
-}
diff --git a/benchmarks/vector-search-bench/src/expression.rs b/benchmarks/vector-search-bench/src/expression.rs
deleted file mode 100644
index b1a5b1ef1c3..00000000000
--- a/benchmarks/vector-search-bench/src/expression.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Cosine-similarity filter [`Expression`]s used by the file-scan path.
-//!
-//! We can easily build a cosine similarity filter by hand:
-//!
-//! ```text
-//! gt(
-//!     cosine_similarity(col("emb"), lit(query_scalar)),
-//!     lit(threshold),
-//! )
-//! ```
-//!
-//! The query is wrapped as `Scalar::extension::<Vector>(Scalar::fixed_size_list(F32, ...))` so
-//! [`CosineSimilarity`] can treat it as a single-row `Vector` value during evaluation.
-//!
-//! At scan time the literal expands into a `ConstantArray` whose row count matches the chunk batch
-//! size.
-
-use anyhow::Result;
-use vortex::array::expr::Expression;
-use vortex::array::expr::col;
-use vortex::array::expr::gt;
-use vortex::array::expr::lit;
-use vortex::array::extension::EmptyMetadata;
-use vortex::array::scalar::Scalar;
-use vortex::array::scalar_fn::EmptyOptions;
-use vortex::array::scalar_fn::ScalarFnVTableExt;
-use vortex::dtype::DType;
-use vortex::dtype::Nullability;
-use vortex::dtype::PType;
-use vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity;
-use vortex_tensor::vector::Vector;
-
-/// Build the filter `cosine_similarity(emb, query) > threshold`.
-pub fn similarity_filter(query: &[f32], threshold: f32) -> Result<Expression> {
-    // Empty queries short-circuit to a literal `false`, so scans return no rows instead of trying
-    // to evaluate cosine similarity on a zero-dimensional vector.
-    if query.is_empty() {
-        return Ok(lit(false));
-    }
-
-    let query_lit = lit(query_scalar(query)?);
-    let cosine = CosineSimilarity.new_expr(EmptyOptions, [col("emb"), query_lit]);
-    Ok(gt(cosine, lit(threshold)))
-}
-
-/// Wrap a query vector as `Scalar::extension::<Vector>(Scalar::fixed_size_list(F32, ...))`.
-pub fn query_scalar(query: &[f32]) -> Result<Scalar> {
-    let children: Vec<Scalar> = query
-        .iter()
-        .map(|&v| Scalar::primitive(v, Nullability::NonNullable))
-        .collect();
-
-    let element_dtype = DType::Primitive(PType::F32, Nullability::NonNullable);
-    let fsl = Scalar::fixed_size_list(element_dtype, children, Nullability::NonNullable);
-
-    Ok(Scalar::extension::<Vector>(EmptyMetadata, fsl))
-}
-
-/// Project just the `emb` column. Used by the throughput-only scan path.
-pub fn emb_projection() -> Expression {
-    col("emb")
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn query_scalar_accepts_empty_query() {
-        let scalar = query_scalar(&[]).unwrap();
-        match scalar.dtype() {
-            DType::Extension(_) => {}
-            other => panic!("expected Extension, got {other}"),
-        }
-    }
-
-    #[test]
-    fn query_scalar_builds_extension_dtype() {
-        let scalar = query_scalar(&[1.0, 0.0, 0.0]).unwrap();
-        match scalar.dtype() {
-            DType::Extension(_) => {}
-            other => panic!("expected Extension, got {other}"),
-        }
-    }
-
-    #[test]
-    fn similarity_filter_uses_gt_operator() {
-        let expr = similarity_filter(&[1.0, 0.0, 0.0], 0.5).unwrap();
-        // Quick sanity check: the printed form contains the operator and the threshold so
-        // future refactors that change the structure get caught here.
-        let printed = format!("{expr:?}");
-        assert!(printed.contains("Gt") || printed.contains(">"), "{printed}");
-    }
-}
diff --git a/benchmarks/vector-search-bench/src/ingest.rs b/benchmarks/vector-search-bench/src/ingest.rs
deleted file mode 100644
index bab176b0482..00000000000
--- a/benchmarks/vector-search-bench/src/ingest.rs
+++ /dev/null
@@ -1,221 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Per-chunk ingest transform.
-//!
-//! Bridges the parquet record-batch stream and the Vortex file writer:
-//!
-//! 1. Project the `emb` column out of each struct chunk.
-//! 2. Rewrap the `emb` column as `Extension<Vector<f32, dim>>` via
-//!    [`vortex_bench::vector_dataset::list_to_vector_ext`].
-//! 3. Detect the FSL element ptype at runtime and cast `f64` -> `f32` when needed. Detection is
-//!    from the arrow schema rather than a catalog declaration so upstream parquets whose actual
-//!    precision disagrees with the catalog still ingest correctly. After this point all
-//!    downstream code (compression, scan, recall) is f32-only.
-//! 4. Optionally project the `scalar_labels` column through unchanged so future filtered-search
-//!    benchmarks have it without re-ingest.
-//! 5. Repackage as `Struct { id: i64, emb: Vector<f32, dim>, scalar_labels: ??? }`.
-
-use anyhow::Context;
-use anyhow::Result;
-use anyhow::bail;
-use anyhow::ensure;
-use vortex::array::ArrayRef;
-use vortex::array::ExecutionCtx;
-use vortex::array::IntoArray;
-use vortex::array::arrays::ExtensionArray;
-use vortex::array::arrays::FixedSizeListArray;
-use vortex::array::arrays::PrimitiveArray;
-use vortex::array::arrays::Struct;
-use vortex::array::arrays::StructArray;
-use vortex::array::arrays::extension::ExtensionArrayExt;
-use vortex::array::arrays::fixed_size_list::FixedSizeListArrayExt;
-use vortex::array::arrays::struct_::StructArrayExt;
-use vortex::array::extension::EmptyMetadata;
-use vortex::array::validity::Validity;
-use vortex::buffer::Buffer;
-use vortex::dtype::DType;
-use vortex::dtype::PType;
-use vortex::dtype::extension::ExtDType;
-use vortex_bench::vector_dataset::list_to_vector_ext;
-use vortex_tensor::vector::AnyVector;
-use vortex_tensor::vector::Vector;
-
-/// Apply the transform to a single struct chunk and return the rebuilt chunk.
-///
-/// `chunk` must be a non-chunked `Struct { id: i64, emb: List<f32> }`, where all of the list
-/// elements are
-///
-/// The returned array is always a `Struct { id: i64, emb: Vector<f32, dim> }`.
-pub fn transform_chunk(chunk: ArrayRef, ctx: &mut ExecutionCtx) -> Result<ArrayRef> {
-    let struct_view = chunk
-        .as_opt::<Struct>()
-        .with_context(|| format!("ingest: expected struct chunk, got dtype {}", chunk.dtype()))?;
-
-    let id = struct_view
-        .unmasked_field_by_name("id")
-        .context("ingest: chunk missing `id` column")?
-        .clone();
-    let emb = struct_view
-        .unmasked_field_by_name("emb")
-        .context("ingest: chunk missing `emb` column")?
-        .clone();
-
-    let emb_ext: ExtensionArray = list_to_vector_ext(emb)?.execute(ctx)?;
-
-    // Detect the actual FSL element ptype from the extension storage dtype. The dataset catalog
-    // cannot be trusted here: at least one upstream parquet (`sift-medium-5m`) ships f64
-    // embeddings despite the catalog advertising f32.
-    let element_ptype = {
-        let storage_dtype = emb_ext.storage_array().dtype();
-        match storage_dtype {
-            DType::FixedSizeList(elem, ..) => match elem.as_ref() {
-                DType::Primitive(ptype, _) => *ptype,
-                other => bail!("ingest: expected primitive FSL element dtype, got {other}"),
-            },
-            other => bail!("ingest: expected FSL storage dtype, got {other}"),
-        }
-    };
-
-    let f32_vector_array = match element_ptype {
-        PType::F32 => emb_ext.into_array(),
-        PType::F64 => convert_f64_to_f32_vectors(&emb_ext, ctx)?,
-        other => bail!("ingest: unsupported emb element ptype {other}, expected f32 or f64"),
-    };
-
-    let fields = [("id", id), ("emb", f32_vector_array)];
-    Ok(StructArray::from_fields(&fields)?.into_array())
-}
-
-/// Convert a `Vector<f64, dim>` extension array down to `Vector<f32, dim>`.
-///
-/// This conversion is lossy, but we are generally ok with this because most vector search
-/// operations do not demand a high amount of precision.
-fn convert_f64_to_f32_vectors(ext: &ExtensionArray, ctx: &mut ExecutionCtx) -> Result<ArrayRef> {
-    ensure!(ext.ext_dtype().is::<AnyVector>());
-
-    let fsl: FixedSizeListArray = ext.storage_array().clone().execute(ctx)?;
-    let validity = fsl.validity()?;
-    let elements: PrimitiveArray = fsl.elements().clone().execute(ctx)?;
-    ensure!(elements.ptype() == PType::F64);
-
-    let dim = match fsl.dtype() {
-        DType::FixedSizeList(_, dim, _) => *dim,
-        other => bail!("cast_vector_ext_to_f32: expected FSL dtype, got {other}"),
-    };
-
-    let f64_slice = elements.as_slice::<f64>();
-
-    #[expect(
-        clippy::cast_possible_truncation,
-        reason = "this is intentionally lossy"
-    )]
-    let f32_buf: Buffer<f32> = f64_slice
-        .iter()
-        .copied()
-        .map(|double| double as f32)
-        .collect();
-
-    let f32_elements = PrimitiveArray::new::<f32>(f32_buf, Validity::NonNullable).into_array();
-    let new_fsl = FixedSizeListArray::try_new(f32_elements, dim, validity, fsl.len())?;
-    let ext_dtype = ExtDType::<Vector>::try_new(EmptyMetadata, new_fsl.dtype().clone())?.erased();
-
-    Ok(ExtensionArray::new(ext_dtype, new_fsl.into_array()).into_array())
-}
-
-#[cfg(test)]
-mod tests {
-    use vortex::VortexSessionDefault;
-    use vortex::array::VortexSessionExecute;
-    use vortex::array::arrays::List;
-    use vortex::buffer::BufferMut;
-    use vortex::dtype::Nullability;
-    use vortex::session::VortexSession;
-
-    use super::*;
-
-    fn list_chunk_f64(rows: &[&[f64]]) -> ArrayRef {
-        let mut elements = BufferMut::<f64>::with_capacity(rows.iter().map(|r| r.len()).sum());
-        let mut offsets = BufferMut::<i32>::with_capacity(rows.len() + 1);
-        offsets.push(0);
-        for row in rows {
-            for &v in row.iter() {
-                elements.push(v);
-            }
-            offsets.push(i32::try_from(elements.len()).unwrap());
-        }
-        let elements_array =
-            PrimitiveArray::new::<f64>(elements.freeze(), Validity::NonNullable).into_array();
-        let offsets_array =
-            PrimitiveArray::new::<i32>(offsets.freeze(), Validity::NonNullable).into_array();
-        vortex::array::Array::<List>::new(elements_array, offsets_array, Validity::NonNullable)
-            .into_array()
-    }
-
-    fn id_array(ids: &[i64]) -> ArrayRef {
-        PrimitiveArray::new::<i64>(
-            BufferMut::from_iter(ids.iter().copied()).freeze(),
-            Validity::NonNullable,
-        )
-        .into_array()
-    }
-
-    #[test]
-    fn f64_chunk_is_cast_to_f32() -> Result<()> {
-        let session = VortexSession::default();
-        let mut ctx = session.create_execution_ctx();
-
-        let emb = list_chunk_f64(&[&[1.0, 2.0, 3.0], &[4.0, 5.0, 6.0]]);
-        let chunk =
-            StructArray::from_fields(&[("id", id_array(&[0, 1])), ("emb", emb)])?.into_array();
-        let out = transform_chunk(chunk, &mut ctx)?;
-        let out_struct = out
-            .as_opt::<Struct>()
-            .context("transform_chunk should return a Struct array")?;
-        let out_emb = out_struct
-            .unmasked_field_by_name("emb")
-            .context("transform_chunk output should contain an emb field")?
-            .clone();
-        let DType::Extension(ext) = out_emb.dtype() else {
-            panic!("expected extension dtype, got {}", out_emb.dtype());
-        };
-        match ext.storage_dtype() {
-            DType::FixedSizeList(elem, 3, Nullability::NonNullable) => {
-                assert_eq!(
-                    **elem,
-                    DType::Primitive(PType::F32, Nullability::NonNullable)
-                );
-            }
-            other => panic!("unexpected storage dtype {other}"),
-        }
-        Ok(())
-    }
-
-    #[test]
-    fn f32_chunk_passes_through() -> Result<()> {
-        let session = VortexSession::default();
-        let mut ctx = session.create_execution_ctx();
-
-        let mut elements = BufferMut::<f32>::with_capacity(6);
-        for v in [1.0f32, 2.0, 3.0, 4.0, 5.0, 6.0] {
-            elements.push(v);
-        }
-        let mut offsets = BufferMut::<i32>::with_capacity(3);
-        offsets.push(0);
-        offsets.push(3);
-        offsets.push(6);
-        let emb = vortex::array::Array::<List>::new(
-            PrimitiveArray::new::<f32>(elements.freeze(), Validity::NonNullable).into_array(),
-            PrimitiveArray::new::<i32>(offsets.freeze(), Validity::NonNullable).into_array(),
-            Validity::NonNullable,
-        )
-        .into_array();
-        let chunk =
-            StructArray::from_fields(&[("id", id_array(&[0, 1])), ("emb", emb)])?.into_array();
-
-        let out = transform_chunk(chunk, &mut ctx)?;
-        let out_struct = out.as_opt::<Struct>().expect("returns Struct");
-        assert_eq!(out_struct.len(), 2);
-        Ok(())
-    }
-}
diff --git a/benchmarks/vector-search-bench/src/lib.rs b/benchmarks/vector-search-bench/src/lib.rs
deleted file mode 100644
index 76b24390d09..00000000000
--- a/benchmarks/vector-search-bench/src/lib.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! `vector-search-bench` vector similarity-search benchmark over several datasets.
-
-pub mod compression;
-pub mod display;
-pub mod distortion;
-pub mod expression;
-pub mod ingest;
-pub mod prepare;
-pub mod query;
-pub mod scan;
-
-use std::sync::LazyLock;
-
-use anyhow::Result;
-use vortex::VortexSessionDefault;
-use vortex::io::session::RuntimeSessionExt;
-use vortex::session::VortexSession;
-use vortex_bench::vector_dataset::TrainLayout;
-use vortex_bench::vector_dataset::VectorDataset;
-
-pub static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
-    // SAFETY: called from inside the LazyLock initializer, before any other access to
-    // `SESSION`. The first thread to dereference SESSION runs this once.
-    unsafe { std::env::set_var(vortex_tensor::SCALAR_FN_ARRAY_TENSOR_PLUGIN_ENV, "1") };
-
-    let session = VortexSession::default().with_tokio();
-    vortex_tensor::initialize(&session);
-    session
-});
-
-/// Resolve a dataset's [`TrainLayout`].
-///
-/// Every benchmark has different sets of possible dataset layouts available. The user **must**
-/// provide one if there are multiple layouts. But if a dataset only has 1 layout, we can choose
-/// that for them as the default.
-pub fn resolve_layout(
-    dataset: VectorDataset,
-    requested: Option<TrainLayout>,
-) -> Result<TrainLayout> {
-    let layouts = dataset.layouts();
-
-    match requested {
-        Some(layout) => {
-            dataset.validate_layout(layout)?;
-            Ok(layout)
-        }
-        None => {
-            if layouts.len() == 1 {
-                Ok(layouts[0].layout())
-            } else {
-                let allowed = layouts
-                    .iter()
-                    .map(|s| s.layout().label())
-                    .collect::<Vec<_>>()
-                    .join(", ");
-                anyhow::bail!(
-                    "dataset {} hosts multiple layouts ([{}]): pass --layout to pick one",
-                    dataset.name(),
-                    allowed,
-                );
-            }
-        }
-    }
-}
diff --git a/benchmarks/vector-search-bench/src/main.rs b/benchmarks/vector-search-bench/src/main.rs
deleted file mode 100644
index 307c050d221..00000000000
--- a/benchmarks/vector-search-bench/src/main.rs
+++ /dev/null
@@ -1,284 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! `vector-search-bench` benchmarks for cosine-similarity scan and TurboQuant distortion.
-//!
-//! ```sh
-//! cargo run -p vector-search-bench --release -- search \
-//!     --dataset cohere-large-10m \
-//!     --layout partitioned \
-//!     --flavors vortex-uncompressed,vortex-turboquant \
-//!     --iterations 3 \
-//!     --threshold 0.8
-//!
-//! cargo run -p vector-search-bench --release -- distortion \
-//!     --dataset sift-small-500k \
-//!     --bits 4 \
-//!     --samples 4096
-//! ```
-
-use std::path::PathBuf;
-
-use anyhow::Context;
-use anyhow::Result;
-use clap::Parser;
-use clap::Subcommand;
-use vector_search_bench::compression::ALL_VECTOR_FLAVORS;
-use vector_search_bench::compression::VectorFlavor;
-use vector_search_bench::display::DatasetReport;
-use vector_search_bench::display::render;
-use vector_search_bench::distortion::DistortionConfig;
-use vector_search_bench::distortion::run_distortion;
-use vector_search_bench::prepare::CompressedVortexDataset;
-use vector_search_bench::prepare::prepare_all;
-use vector_search_bench::query::get_random_query_vector;
-use vector_search_bench::resolve_layout;
-use vector_search_bench::scan::ScanConfig;
-use vector_search_bench::scan::ScanTiming;
-use vector_search_bench::scan::run_search_scan;
-use vortex_bench::setup_logging_and_tracing;
-use vortex_bench::v3;
-use vortex_bench::vector_dataset;
-use vortex_bench::vector_dataset::TrainLayout;
-use vortex_bench::vector_dataset::VectorDataset;
-
-#[derive(Parser, Debug)]
-#[command(version, about, long_about = None)]
-struct Cli {
-    #[command(subcommand)]
-    command: Command,
-}
-
-#[derive(Subcommand, Debug)]
-enum Command {
-    /// On-disk cosine-similarity scan latency benchmark.
-    Search(SearchArgs),
-    /// TurboQuant distortion measurement: reconstruction error and cosine error.
-    Distortion(DistortionArgs),
-}
-
-#[derive(Parser, Debug)]
-struct SearchArgs {
-    /// Dataset to benchmark. Single dataset per CLI invocation by design — large datasets
-    /// are intentionally babysat one at a time.
-    #[arg(long, value_enum)]
-    dataset: VectorDataset,
-
-    /// Train-split layout. Required when the dataset publishes more than one layout.
-    /// Defaults to the catalog's first hosted layout when omitted.
-    #[arg(long, value_enum)]
-    layout: Option<TrainLayout>,
-
-    /// Comma-separated list of flavors to run. Each Vortex flavor produces one `.vortex` file per
-    /// train shard.
-    #[arg(
-        long,
-        value_delimiter = ',',
-        value_enum,
-        default_values_t = ALL_VECTOR_FLAVORS.to_vec(),
-    )]
-    flavors: Vec<VectorFlavor>,
-
-    /// Number of timed scan iterations per flavor. Mean and median are reported.
-    #[arg(long, default_value_t = 5)]
-    iterations: usize,
-
-    /// Cosine threshold passed to the filter expression.
-    #[arg(long, default_value_t = 0.85)]
-    threshold: f32,
-
-    /// Seed for the test-parquet query sampler.
-    #[arg(long, default_value_t = 42)]
-    query_seed: u64,
-
-    /// Optional path to write the rendered table to instead of stdout.
-    #[arg(long)]
-    output_path: Option<PathBuf>,
-
-    /// Additionally write v3 JSONL records to this path. See
-    /// `benchmarks-website/planning/02-contracts.md`.
-    #[arg(long)]
-    gh_json_v3: Option<PathBuf>,
-
-    /// Emit verbose tracing.
-    #[arg(short, long)]
-    verbose: bool,
-
-    /// Enable perfetto tracing output.
-    #[arg(long)]
-    tracing: bool,
-}
-
-#[derive(Parser, Debug)]
-struct DistortionArgs {
-    /// Dataset to load vectors from. One dataset per invocation.
-    #[arg(long, value_enum)]
-    dataset: VectorDataset,
-
-    /// Train-split layout. Required when the dataset publishes more than one layout.
-    #[arg(long, value_enum)]
-    layout: Option<TrainLayout>,
-
-    /// Bits per quantized coordinate.
-    #[arg(long, default_value_t = 4)]
-    bits: u8,
-
-    /// Seed for the SORF rotation.
-    #[arg(long, default_value_t = 42)]
-    seed: u64,
-
-    /// Number of sign-diagonal plus Walsh-Hadamard rounds in the SORF transform.
-    #[arg(long, default_value_t = 3)]
-    rounds: u8,
-
-    /// Number of base vectors to sample from the first train shard (first N rows).
-    #[arg(long, default_value_t = 65536)]
-    samples: usize,
-
-    /// Optional path to write the rendered table to instead of stdout.
-    #[arg(long)]
-    output_path: Option<PathBuf>,
-
-    /// Emit verbose tracing.
-    #[arg(short, long)]
-    verbose: bool,
-
-    /// Enable perfetto tracing output.
-    #[arg(long)]
-    tracing: bool,
-}
-
-#[tokio::main]
-async fn main() -> Result<()> {
-    let cli = Cli::parse();
-    match cli.command {
-        Command::Search(args) => run_search(args).await,
-        Command::Distortion(args) => run_distortion_cmd(args).await,
-    }
-}
-
-async fn run_search(args: SearchArgs) -> Result<()> {
-    setup_logging_and_tracing(args.verbose, args.tracing)?;
-
-    let dataset = args.dataset;
-    let layout = resolve_layout(dataset, args.layout)?;
-    tracing::info!(
-        "running {} on layout {} ({} dims, {} rows)",
-        dataset.name(),
-        layout,
-        dataset.dim(),
-        dataset.num_rows()
-    );
-
-    if args.flavors.is_empty() {
-        anyhow::bail!("no flavors selected, please pass at least one to --flavors");
-    }
-
-    let datasets_paths = vector_dataset::download(dataset, layout)
-        .await
-        .with_context(|| format!("download {}", dataset.name()))?;
-
-    let prepared = prepare_all(dataset, layout, &datasets_paths, &args.flavors).await?;
-
-    let query_vector = get_random_query_vector(
-        &datasets_paths.test,
-        dataset.dim(),
-        dataset.element_ptype(),
-        args.query_seed,
-    )
-    .await?;
-    tracing::info!(
-        "sampled query id {} (dim={})",
-        query_vector.id,
-        query_vector.query.len()
-    );
-
-    let scan_config = ScanConfig {
-        iterations: args.iterations,
-        threshold: args.threshold,
-    };
-
-    let mut scan_timings: Vec<ScanTiming> = Vec::with_capacity(prepared.len());
-    for prep in &prepared {
-        let timing = run_search_scan(prep, &query_vector.query, &scan_config).await?;
-        scan_timings.push(timing);
-    }
-
-    let pairs: Vec<(VectorFlavor, &CompressedVortexDataset, &ScanTiming)> = prepared
-        .iter()
-        .zip(scan_timings.iter())
-        .map(|(prep, scan)| (prep.flavor, prep, scan))
-        .collect();
-    let report = DatasetReport {
-        dataset_name: dataset.name(),
-        vortex_results: &pairs,
-    };
-
-    if let Some(path) = args.gh_json_v3.as_ref() {
-        let records: Vec<v3::V3Record> = scan_timings
-            .iter()
-            .map(|scan| {
-                let all_runs_ns: Vec<u64> = scan
-                    .all_runs
-                    .iter()
-                    .map(|d| u64::try_from(d.as_nanos()).unwrap_or(u64::MAX))
-                    .collect();
-                let median_ns = u64::try_from(scan.median.as_nanos()).unwrap_or(u64::MAX);
-                v3::vector_search_record(
-                    v3::VectorSearchDims {
-                        dataset: dataset.name(),
-                        layout: layout.label(),
-                        flavor: scan.flavor.label(),
-                        threshold: f64::from(args.threshold),
-                    },
-                    median_ns,
-                    all_runs_ns,
-                    scan.matches,
-                    scan.rows_scanned,
-                    scan.bytes_scanned,
-                )
-            })
-            .collect();
-        v3::write_jsonl_to_path(path, &records)?;
-    }
-
-    if let Some(path) = args.output_path {
-        let mut file =
-            std::fs::File::create(&path).with_context(|| format!("create {}", path.display()))?;
-        render(&report, &mut file)?;
-    } else {
-        let stdout = std::io::stdout();
-        let mut handle = stdout.lock();
-        render(&report, &mut handle)?;
-    }
-
-    Ok(())
-}
-
-async fn run_distortion_cmd(args: DistortionArgs) -> Result<()> {
-    setup_logging_and_tracing(args.verbose, args.tracing)?;
-
-    let layout = resolve_layout(args.dataset, args.layout)?;
-    let config = DistortionConfig {
-        dataset: args.dataset,
-        layout,
-        bits: args.bits,
-        seed: args.seed,
-        rounds: args.rounds,
-        samples: args.samples,
-    };
-
-    let report = run_distortion(&config).await?;
-
-    if let Some(path) = args.output_path {
-        let mut file =
-            std::fs::File::create(&path).with_context(|| format!("create {}", path.display()))?;
-        report.render(&mut file)?;
-    } else {
-        let stdout = std::io::stdout();
-        let mut handle = stdout.lock();
-        report.render(&mut handle)?;
-    }
-
-    Ok(())
-}
diff --git a/benchmarks/vector-search-bench/src/prepare.rs b/benchmarks/vector-search-bench/src/prepare.rs
deleted file mode 100644
index 8cf9d9860ed..00000000000
--- a/benchmarks/vector-search-bench/src/prepare.rs
+++ /dev/null
@@ -1,227 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Per-flavor on-disk ingest.
-//!
-//! For each `(dataset, layout, flavor)` triple, [`prepare_flavor`] streams every parquet shard
-//! and writes one `.vortex` file per shard. The pipeline is idempotent (existing `.vortex` files
-//! are skipped) and reports end-to-end wall-clock time, summed input parquet bytes, and total
-//! output bytes.
-
-use std::path::Path;
-use std::path::PathBuf;
-
-use anyhow::Context;
-use anyhow::Result;
-use futures::StreamExt;
-use parquet::arrow::ParquetRecordBatchStreamBuilder;
-use tokio::fs::File;
-use tokio::io::AsyncWriteExt;
-use tracing::info;
-use tracing::warn;
-use vortex::array::ArrayRef;
-use vortex::array::ExecutionCtx;
-use vortex::array::VortexSessionExecute;
-use vortex::array::stream::ArrayStreamAdapter;
-use vortex::array::stream::ArrayStreamExt;
-use vortex::error::VortexResult;
-use vortex::error::vortex_err;
-use vortex_bench::conversions::parquet_to_vortex_stream;
-use vortex_bench::data_dir;
-use vortex_bench::utils::file::idempotent_async;
-use vortex_bench::vector_dataset::DatasetPaths;
-use vortex_bench::vector_dataset::TrainLayout;
-use vortex_bench::vector_dataset::VectorDataset;
-
-use crate::SESSION;
-use crate::compression::VectorFlavor;
-use crate::ingest::transform_chunk;
-
-/// The paths of the vortex files that result from preparing one `(dataset, layout, flavor)` triple.
-#[derive(Debug, Clone)]
-pub struct CompressedVortexDataset {
-    pub dataset: VectorDataset,
-    pub layout: TrainLayout,
-    pub flavor: VectorFlavor,
-    pub vortex_files: Vec<PathBuf>,
-}
-
-/// Drive [`prepare_flavor`] across a list of flavors, returning a [`CompressedVortexDataset`] per
-/// flavor in input order.
-pub async fn prepare_all(
-    dataset: VectorDataset,
-    layout: TrainLayout,
-    paths_for_dataset: &DatasetPaths,
-    flavors: &[VectorFlavor],
-) -> Result<Vec<CompressedVortexDataset>> {
-    let mut results = Vec::with_capacity(flavors.len());
-
-    for &flavor in flavors {
-        let r = prepare_flavor(dataset, layout, paths_for_dataset, flavor).await?;
-        results.push(r);
-    }
-
-    Ok(results)
-}
-
-/// Prepare one flavor of one dataset by writing one `.vortex` file per train shard.
-///
-/// This function is sequential (for now).
-pub async fn prepare_flavor(
-    dataset: VectorDataset,
-    layout: TrainLayout,
-    paths_for_dataset: &DatasetPaths,
-    flavor: VectorFlavor,
-) -> Result<CompressedVortexDataset> {
-    let mut vortex_files = Vec::with_capacity(paths_for_dataset.train_files.len());
-
-    for parquet_path in &paths_for_dataset.train_files {
-        let parquet_path = parquet_path.clone();
-        let vortex_path = parquet_to_vortex_path(&parquet_path, dataset, layout, flavor)?;
-
-        let already_cached = vortex_path.exists();
-        if already_cached {
-            warn!(
-                "skipping cached vortex shard {} ({} flavor)",
-                vortex_path.display(),
-                flavor.label()
-            );
-        } else {
-            info!(
-                "ingesting {} -> {} ({} flavor)",
-                parquet_path.display(),
-                vortex_path.display(),
-                flavor.label(),
-            );
-        }
-
-        let written_path = idempotent_async(vortex_path.as_path(), |tmp| async move {
-            write_shard_streaming(&parquet_path, &tmp, flavor).await
-        })
-        .await?;
-
-        vortex_files.push(written_path);
-    }
-
-    Ok(CompressedVortexDataset {
-        dataset,
-        layout,
-        flavor,
-        vortex_files,
-    })
-}
-
-/// Stream one parquet shard through the chunk transform into a Vortex file.
-///
-/// The output dtype is derived once from the first transformed chunk so the [`ArrayStreamAdapter`]
-/// can declare it ahead of time.
-async fn write_shard_streaming(
-    parquet_path: &Path,
-    vortex_path: &Path,
-    flavor: VectorFlavor,
-) -> Result<()> {
-    let file = File::open(parquet_path).await?;
-    let builder = ParquetRecordBatchStreamBuilder::new(file).await?;
-    let mut array_stream = parquet_to_vortex_stream(builder.build()?);
-
-    let mut ctx = SESSION.create_execution_ctx();
-
-    // We need to get the first chunk so that we know what the dtype of the file is.
-    let first = match array_stream.next().await {
-        Some(chunk) => transform_chunk_with_error(chunk, &mut ctx, parquet_path, 1)?,
-        None => {
-            return Err(vortex_err!(
-                "ingest: parquet shard {} produced no chunks",
-                parquet_path.display(),
-            )
-            .into());
-        }
-    };
-    let dtype = first.dtype().clone();
-    let shard_path = parquet_path.to_path_buf();
-
-    let transformed =
-        futures::stream::iter(std::iter::once(Ok(first))).chain(array_stream.enumerate().map(
-            move |(chunk_offset, chunk_or_err)| {
-                let mut local_ctx = SESSION.create_execution_ctx();
-                transform_chunk_with_error(
-                    chunk_or_err,
-                    &mut local_ctx,
-                    &shard_path,
-                    chunk_offset + 2,
-                )
-            },
-        ));
-
-    let stream = ArrayStreamExt::boxed(ArrayStreamAdapter::new(dtype, transformed));
-
-    let mut output = tokio::fs::OpenOptions::new()
-        .write(true)
-        .truncate(true)
-        .create(true)
-        .open(vortex_path)
-        .await?;
-
-    flavor
-        .create_write_options(&SESSION)
-        .write(&mut output, stream)
-        .await?;
-    output.flush().await?;
-
-    Ok(())
-}
-
-fn transform_chunk_with_error(
-    chunk_or_err: VortexResult<ArrayRef>,
-    ctx: &mut ExecutionCtx,
-    parquet_path: &Path,
-    chunk_idx: usize,
-) -> VortexResult<ArrayRef> {
-    let chunk = chunk_or_err.map_err(|err| {
-        vortex_err!(
-            "ingest: failed to read chunk {} from {}: {err:#}",
-            chunk_idx,
-            parquet_path.display(),
-        )
-    })?;
-
-    transform_chunk(chunk, ctx).map_err(|err| {
-        vortex_err!(
-            "ingest: failed to transform chunk {} from {}: {err:#}",
-            chunk_idx,
-            parquet_path.display(),
-        )
-    })
-}
-
-/// Translate a parquet shard path to its `.vortex` companion under the flavor directory.
-///
-/// Just swaps the file extension and rebases the file name into the per-[`VectorFlavor`] flavor
-/// directory. The shard stem is preserved so a directory listing pairs `00-of-10.parquet` with
-/// `00-of-10.vortex`.
-pub fn parquet_to_vortex_path(
-    parquet: &Path,
-    dataset: VectorDataset,
-    layout: TrainLayout,
-    flavor: VectorFlavor,
-) -> Result<PathBuf> {
-    let stem = parquet
-        .file_stem()
-        .with_context(|| format!("parquet path {} has no file stem", parquet.display()))?
-        .to_owned();
-
-    // TODO(connor): Is there a better way to do this?
-    let mut name = stem;
-    name.push(".vortex");
-
-    Ok(flavor_dir(dataset, layout, flavor).join(name))
-}
-
-/// `vortex-bench/data/vector-search/<dataset>/<layout>/<flavor>/`.
-fn flavor_dir(ds: VectorDataset, layout: TrainLayout, flavor: VectorFlavor) -> PathBuf {
-    data_dir()
-        .join("vector-search")
-        .join(ds.name())
-        .join(layout.label())
-        .join(flavor.dir_name())
-}
diff --git a/benchmarks/vector-search-bench/src/query.rs b/benchmarks/vector-search-bench/src/query.rs
deleted file mode 100644
index cbd9d3bf38e..00000000000
--- a/benchmarks/vector-search-bench/src/query.rs
+++ /dev/null
@@ -1,120 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Sample one query vector from `test.parquet`.
-//!
-//! The vector datasets ship a `test.parquet` alongside the train split: these are the query vectors
-//! meant to be issued against the index.
-//!
-//! The benchmark picks a single random row (seeded for reproducibility) and uses it as the query
-//! for the scan.
-
-use std::path::Path;
-
-use anyhow::Context;
-use anyhow::Result;
-use anyhow::bail;
-use anyhow::ensure;
-use rand::RngExt;
-use rand::SeedableRng;
-use rand::rngs::StdRng;
-use vortex::array::IntoArray;
-use vortex::array::VortexSessionExecute;
-use vortex::array::arrays::StructArray;
-use vortex::array::arrays::struct_::StructArrayExt;
-use vortex::dtype::PType;
-use vortex::error::VortexExpect;
-use vortex::error::vortex_err;
-use vortex_bench::conversions::parquet_to_vortex_chunks;
-
-use crate::SESSION;
-
-/// One query vector sampled from `test.parquet`.
-#[derive(Debug, Clone)]
-pub struct QuerySample {
-    /// The ID of the vector.
-    pub id: i64,
-    /// f32 query values, length `dim`.
-    pub query: Vec<f32>,
-}
-
-/// Sample one query row from `test.parquet`.
-///
-/// The cast to f32 happens here when the source is f64 (matching the prepare-side cast), so that
-/// all downstream code is uniformly f32.
-pub async fn get_random_query_vector(
-    test_parquet: &Path,
-    expected_dim: u32,
-    src_ptype: PType,
-    seed: u64,
-) -> Result<QuerySample> {
-    let mut ctx = SESSION.create_execution_ctx();
-
-    let chunked = parquet_to_vortex_chunks(test_parquet.to_path_buf())
-        .await
-        .with_context(|| format!("read test parquet {}", test_parquet.display()))?;
-    // The `test.parquet` files are generally small enough that this is not a big deal.
-    let struct_array: StructArray = chunked.into_array().execute(&mut ctx)?;
-
-    let id = struct_array
-        .unmasked_field_by_name("id")
-        .context("test parquet missing `id` column")?
-        .clone();
-    let emb = struct_array
-        .unmasked_field_by_name("emb")
-        .context("test parquet missing `emb` column")?
-        .clone();
-
-    let mut rng = StdRng::seed_from_u64(seed);
-    let query_row_idx = rng.random_range(0..id.len());
-
-    let id_scalar = id.execute_scalar(query_row_idx, &mut ctx)?;
-    let emb_scalar = emb.execute_scalar(query_row_idx, &mut ctx)?;
-
-    ensure!(emb_scalar.as_list().len() == expected_dim as usize);
-
-    let id = id_scalar
-        .as_primitive()
-        .as_::<i64>()
-        .ok_or_else(|| vortex_err!("vector ID was not a i64"))?;
-
-    let query_vector = match src_ptype {
-        PType::F32 => emb_scalar
-            .as_list()
-            .elements()
-            .vortex_expect("somehow had a null test vector")
-            .iter()
-            .map(|element| {
-                element
-                    .as_primitive()
-                    .as_::<f32>()
-                    .vortex_expect("value was not a f32")
-            })
-            .collect(),
-        PType::F64 =>
-        {
-            #[expect(
-                clippy::cast_possible_truncation,
-                reason = "this is intentionally lossy"
-            )]
-            emb_scalar
-                .as_list()
-                .elements()
-                .vortex_expect("somehow had a null test vector")
-                .iter()
-                .map(|element| {
-                    element
-                        .as_primitive()
-                        .as_::<f64>()
-                        .vortex_expect("value was not a f64") as f32
-                })
-                .collect()
-        }
-        ptype => bail!("source ptype {ptype} was somehow not f32 or f64"),
-    };
-
-    Ok(QuerySample {
-        query: query_vector,
-        id,
-    })
-}
diff --git a/benchmarks/vector-search-bench/src/scan.rs b/benchmarks/vector-search-bench/src/scan.rs
deleted file mode 100644
index 81a054f74b3..00000000000
--- a/benchmarks/vector-search-bench/src/scan.rs
+++ /dev/null
@@ -1,177 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Per-iteration scan driver.
-//!
-//! Each iteration re-opens every `.vortex` shard fresh (so the segment cache is re-primed
-//! per run), pushes the cosine-similarity filter through the scan, and drains the resulting
-//! [`vortex::array::stream::ArrayStream`]. The wall-clock around the entire per-iteration
-//! pass is the headline number; we track the mean and median across iterations.
-
-use std::path::Path;
-use std::path::PathBuf;
-use std::time::Duration;
-use std::time::Instant;
-
-use anyhow::Context;
-use anyhow::Result;
-use futures::TryStreamExt;
-use vortex::array::ArrayRef;
-use vortex::file::OpenOptionsSessionExt;
-
-use crate::SESSION;
-use crate::compression::VectorFlavor;
-use crate::expression::similarity_filter;
-use crate::prepare::CompressedVortexDataset;
-
-/// Inputs to a scan run.
-#[derive(Debug, Clone)]
-pub struct ScanConfig {
-    /// Number of timed iterations (best-of-N).
-    pub iterations: usize,
-    /// Cosine threshold passed to the filter expression.
-    pub threshold: f32,
-}
-
-/// Aggregate timing + counters for one `(flavor)` scan.
-#[derive(Debug, Clone)]
-pub struct ScanTiming {
-    /// Which compression flavor's `.vortex` files were scanned.
-    pub flavor: VectorFlavor,
-    /// Arithmetic mean of the per-iteration wall times.
-    pub mean: Duration,
-    /// Median of the per-iteration wall times.
-    pub median: Duration,
-    /// Per-iteration wall times in run order.
-    pub all_runs: Vec<Duration>,
-    /// Number of rows that survived the filter (constant across iterations because the
-    /// filter is deterministic).
-    pub matches: u64,
-    /// Total rows scanned (sum of file row counts) as a sanity check that the iteration
-    /// actually walked the files.
-    pub rows_scanned: u64,
-    /// Total on-disk size of the scanned `.vortex` files, in bytes.
-    pub bytes_scanned: u64,
-}
-
-/// Scan every shard in a [`CompressedVortexDataset`] under the given config.
-pub async fn run_search_scan(
-    dataset: &CompressedVortexDataset,
-    query: &[f32],
-    config: &ScanConfig,
-) -> Result<ScanTiming> {
-    anyhow::ensure!(
-        config.iterations > 0,
-        "scan iterations must be >= 1, got {}",
-        config.iterations
-    );
-
-    let bytes_scanned = total_file_size(&dataset.vortex_files)?;
-
-    let mut all_runs = Vec::with_capacity(config.iterations);
-    let mut matches = 0u64;
-    let mut rows_scanned = 0u64;
-
-    for iter_idx in 0..config.iterations {
-        let (wall, iter_matches, iter_rows) =
-            run_one_iteration(&dataset.vortex_files, query, config.threshold).await?;
-        tracing::debug!(
-            "{} iter {} -> {:?} ({} matches, {} rows)",
-            dataset.flavor.label(),
-            iter_idx,
-            wall,
-            iter_matches,
-            iter_rows,
-        );
-        // Matches and row counts are deterministic across iterations; reset rather than
-        // accumulate so the reported value matches a single pass.
-        matches = iter_matches;
-        rows_scanned = iter_rows;
-        all_runs.push(wall);
-    }
-
-    Ok(ScanTiming {
-        flavor: dataset.flavor,
-        mean: mean(&all_runs),
-        median: median(&all_runs),
-        all_runs,
-        matches,
-        rows_scanned,
-        bytes_scanned,
-    })
-}
-
-/// Sum the on-disk sizes of the given files.
-fn total_file_size(paths: &[PathBuf]) -> Result<u64> {
-    let mut total = 0u64;
-    for path in paths {
-        let meta =
-            std::fs::metadata(path).with_context(|| format!("stat {} for size", path.display()))?;
-        total = total.saturating_add(meta.len());
-    }
-    Ok(total)
-}
-
-async fn run_one_iteration(
-    vortex_files: &[PathBuf],
-    query: &[f32],
-    threshold: f32,
-) -> Result<(Duration, u64, u64)> {
-    let mut matches = 0u64;
-    let mut rows_scanned = 0u64;
-
-    let started = Instant::now();
-    for path in vortex_files {
-        let (m, r) = scan_one_file(path, query, threshold).await?;
-        matches = matches.saturating_add(m);
-        rows_scanned = rows_scanned.saturating_add(r);
-    }
-
-    Ok((started.elapsed(), matches, rows_scanned))
-}
-
-async fn scan_one_file(path: &Path, query: &[f32], threshold: f32) -> Result<(u64, u64)> {
-    let file = SESSION
-        .open_options()
-        .open_path(path)
-        .await
-        .with_context(|| format!("open {}", path.display()))?;
-
-    let total_rows = file.row_count();
-    let filter = similarity_filter(query, threshold)?;
-    let chunks: Vec<ArrayRef> = file
-        .scan()?
-        .with_filter(filter)
-        .into_array_stream()?
-        .try_collect()
-        .await?;
-
-    let matches: u64 = chunks.iter().map(|c| c.len() as u64).sum();
-    Ok((matches, total_rows))
-}
-
-/// Arithmetic mean of a list of [`Duration`]s. Empty lists return [`Duration::ZERO`].
-pub fn mean(runs: &[Duration]) -> Duration {
-    if runs.is_empty() {
-        return Duration::ZERO;
-    }
-    let total_nanos: u128 = runs.iter().map(|d| d.as_nanos()).sum();
-    let avg_nanos = total_nanos / runs.len() as u128;
-    Duration::from_nanos(u64::try_from(avg_nanos).unwrap_or(u64::MAX))
-}
-
-/// Median of a list of [`Duration`]s. Empty lists return [`Duration::ZERO`].
-pub fn median(runs: &[Duration]) -> Duration {
-    if runs.is_empty() {
-        return Duration::ZERO;
-    }
-    let mut sorted = runs.to_vec();
-    sorted.sort();
-    let mid = sorted.len() / 2;
-    if sorted.len() % 2 == 1 {
-        sorted[mid]
-    } else {
-        let total_nanos = sorted[mid - 1].as_nanos() + sorted[mid].as_nanos();
-        Duration::from_nanos(u64::try_from(total_nanos / 2).unwrap_or(u64::MAX))
-    }
-}
diff --git a/deny.toml b/deny.toml
index 64814519f91..b9f9c79a796 100644
--- a/deny.toml
+++ b/deny.toml
@@ -15,6 +15,8 @@ feature-depth = 1
 ignore = [
     # Paste is no longer maintained because its essentially "finished".
     "RUSTSEC-2024-0436",
+    # proc-macro-error-2 is unmaintained, only used by the `test_with` test dependency
+    "RUSTSEC-2026-0173"
 ]
 
 [licenses]
diff --git a/docs/specs/index.md b/docs/specs/index.md
index 547cd99f182..045ccb0710d 100644
--- a/docs/specs/index.md
+++ b/docs/specs/index.md
@@ -11,4 +11,5 @@ file-format
 ipc-format
 dtype-format
 scalar-format
+row-encoding
 ```
diff --git a/docs/specs/row-encoding.md b/docs/specs/row-encoding.md
new file mode 100644
index 00000000000..8fc3288f82b
--- /dev/null
+++ b/docs/specs/row-encoding.md
@@ -0,0 +1,539 @@
+# Row Encoding Byte Sort Specification
+
+This document describes the byte-sortable row encoding implemented by the `vortex-row`
+crate. The encoding converts one or more columnar arrays into a `ListView<u8>` array. Each
+output row is a byte string, and lexicographic byte comparison of those byte strings matches
+logical tuple comparison of the input values under the configured row sort options.
+
+This is a schema-aware row-key format. The bytes do not contain type tags, field names, or
+sort options. Two encoded rows are comparable only when they were produced with the same
+input schema and the same per-column `RowSortField` settings.
+
+The row encoding is not the Vortex file format or scalar IPC format. It is an internal
+comparison representation used for sort keys and row-key operations.
+
+:::{warning}
+The row encoding format is experimental. Its byte layout, supported type set, and edge-case
+semantics may change between Vortex releases. Do not persist these bytes or depend on them as
+a stable interchange format.
+:::
+
+## Order Property
+
+For a fixed schema with columns `c0, c1, ..., cn` and per-column sort fields
+`f0, f1, ..., fn`, row encoding provides this property:
+
+```text
+encode(row_a) < encode(row_b)
+```
+
+if and only if tuple comparison says:
+
+```text
+(row_a.c0, row_a.c1, ..., row_a.cn) < (row_b.c0, row_b.c1, ..., row_b.cn)
+```
+
+using the requested ascending or descending direction and requested null placement for each
+column.
+
+The property is built from two rules:
+
+1. Each supported scalar or nested value is encoded so its bytes sort in the same order as
+   the value.
+2. Fields are concatenated from left to right, so lexicographic byte comparison naturally
+   performs tuple comparison.
+
+## Notation
+
+This document uses the following notation:
+
+- `||` means byte concatenation.
+- `BE(x)` means the fixed-width big-endian bytes of `x`.
+- `!b` means `b XOR 0xFF`.
+- `!bytes` means bitwise complement of every byte in `bytes`.
+- `zero(n)` means `n` zero bytes.
+- `ff(n)` means `n` bytes of `0xFF`.
+- `width(T)` means the native byte width of fixed-width type `T`.
+
+`BE(x)` always emits exactly the byte width of the value being encoded, with the most
+significant byte first. It is not length-prefixed and it does not drop leading zero or
+leading `0xFF` bytes. The host machine's native endianness is irrelevant; encoders produce
+these bytes explicitly.
+
+For example:
+
+| Value and type | `BE(value)` |
+| --- | --- |
+| `1_u8` | `01` |
+| `258_u16` | `01 02` |
+| `258_u32` | `00 00 01 02` |
+| `-5_i32`, before the signed sign-bit transform | `FF FF FF FB` |
+| `ordered = 0x80000000_u32` | `80 00 00 00` |
+
+## Field Options
+
+Each input column has a `RowSortField`:
+
+```text
+RowSortField {
+    descending: bool,
+    nulls_first: bool,
+}
+```
+
+`descending` reverses the order of non-null values. `nulls_first` is independent of
+`descending`, so nulls can sort before or after non-nulls in either direction.
+
+## Sentinel Summary
+
+Sentinels are single bytes that classify nullness and, for variable-width values, whether a
+value is empty or non-empty. They are chosen so byte comparison can decide those categories
+before comparing any value bytes.
+
+| Encoding family | Case | Ascending, nulls first | Descending, nulls first | Ascending, nulls last | Descending, nulls last |
+| --- | --- | --- | --- | --- | --- |
+| Fixed-width | Null | `0x00` | `0x00` | `0x02` | `0x02` |
+| Fixed-width | Non-null | `0x01` | `0x01` | `0x01` | `0x01` |
+| Variable-width | Null | `0x00` | `0x00` | `0xFF` | `0xFF` |
+| Variable-width | Empty | `0x01` | `0xFE` | `0x01` | `0xFE` |
+| Variable-width | Non-empty | `0x02` | `0xFD` | `0x02` | `0xFD` |
+
+Fixed-width sentinels are used by null, boolean, primitive, decimal, struct, and fixed-size
+list values. Variable-width sentinels are used by UTF-8 and binary values.
+
+## Fixed-Width Sentinels
+
+Every fixed-width value starts with a one-byte sentinel:
+
+| Case | Sentinel |
+| --- | --- |
+| Null, `nulls_first = true` | `0x00` |
+| Non-null | `0x01` |
+| Null, `nulls_first = false` | `0x02` |
+
+The sentinel is not inverted for descending order. Only the non-null value bytes are
+inverted. This keeps null placement independent from sort direction.
+
+For fixed-width nulls, the sentinel is followed by zero-filled value bytes. This gives fixed
+types a constant encoded width for every row.
+
+## Variable-Width Sentinels
+
+UTF-8 and binary values use three leading sentinels. The separate empty and non-empty
+sentinels are important: they ensure the first byte decides null, empty, or non-empty before
+later columns can affect comparison.
+
+| Case | Ascending | Descending |
+| --- | --- | --- |
+| Null, `nulls_first = true` | `0x00` | `0x00` |
+| Empty | `0x01` | `0xFE` |
+| Non-empty | `0x02` | `0xFD` |
+| Null, `nulls_first = false` | `0xFF` | `0xFF` |
+
+The null sentinel is not inverted by descending order. Empty and non-empty sentinels are
+inverted so non-null value order is reversed while null placement stays fixed.
+
+## Null
+
+`Null` values have no body:
+
+```text
+fixed_null_sentinel
+```
+
+The sentinel is `0x00` for nulls-first and `0x02` for nulls-last.
+
+## Boolean
+
+Booleans are fixed-width and use one value byte:
+
+```text
+sentinel || value_byte
+```
+
+For ascending order:
+
+| Value | Value byte |
+| --- | --- |
+| `false` | `0x01` |
+| `true` | `0x02` |
+
+For descending order, the value byte is inverted:
+
+| Value | Value byte |
+| --- | --- |
+| `true` | `0xFD` |
+| `false` | `0xFE` |
+
+Null booleans encode as:
+
+```text
+null_sentinel || 0x00
+```
+
+## Unsigned Integers
+
+Supported unsigned primitive types are `u8`, `u16`, `u32`, and `u64`.
+
+Ascending encoding:
+
+```text
+0x01 || BE(value)
+```
+
+Descending encoding:
+
+```text
+0x01 || !BE(value)
+```
+
+Big-endian byte order makes lexicographic byte order match numeric order for fixed-width
+unsigned integers. Bitwise complement reverses that order for descending fields.
+
+Null unsigned integers encode as:
+
+```text
+null_sentinel || zero(width(T))
+```
+
+## Signed Integers
+
+Supported signed primitive PTypes are `i8`, `i16`, `i32`, and `i64`. The same signed
+integer transform is also used for `i128` decimal storage.
+
+Signed integers first flip the sign bit of their big-endian two's-complement
+representation:
+
+```text
+ordered = BE(value)
+ordered[0] = ordered[0] XOR 0x80
+```
+
+Ascending encoding:
+
+```text
+0x01 || ordered
+```
+
+Descending encoding:
+
+```text
+0x01 || !ordered
+```
+
+Flipping the sign bit maps the signed numeric range into unsigned byte order:
+
+```text
+negative values -> 0x00..0x7F prefix range
+non-negative values -> 0x80..0xFF prefix range
+```
+
+Null signed integers encode as:
+
+```text
+null_sentinel || zero(width(T))
+```
+
+## Floating Point
+
+Supported floating primitive types are `f16`, `f32`, and `f64`.
+
+The encoder treats the IEEE bit pattern as an unsigned integer and applies a sign-aware
+transform before writing big-endian bytes.
+
+For a floating value with raw bits `bits`:
+
+```text
+if sign_bit(bits) == 0:
+    ordered = bits XOR sign_bit_mask
+else:
+    ordered = bits XOR all_ones
+```
+
+Ascending encoding:
+
+```text
+0x01 || BE(ordered)
+```
+
+Descending encoding:
+
+```text
+0x01 || !BE(ordered)
+```
+
+This produces a total-order-style byte ordering where negative values sort before positive
+values, and `-0.0` sorts before `+0.0`. NaN values are ordered by their raw bit patterns
+under the same transform; they are not canonicalized by row encoding.
+
+Null floats encode as:
+
+```text
+null_sentinel || zero(width(T))
+```
+
+## Decimal
+
+Decimals are encoded as their scaled signed integer storage value. The selected storage
+width is the smallest decimal value type for the decimal precision:
+
+| Precision | Storage |
+| --- | --- |
+| `1..=2` | `i8` |
+| `3..=4` | `i16` |
+| `5..=9` | `i32` |
+| `10..=18` | `i64` |
+| `19..=38` | `i128` |
+
+The storage integer is encoded with the signed integer encoding described above. Decimal
+columns have one precision and scale, so ordering the scaled integer storage values matches
+ordering the decimal values in that column.
+
+`Decimal256` is not supported by row encoding.
+
+## UTF-8 and Binary
+
+UTF-8 and binary values use the variable-width sentinels described above.
+
+Null:
+
+```text
+varlen_null_sentinel
+```
+
+Empty:
+
+```text
+varlen_empty_sentinel
+```
+
+Non-empty:
+
+```text
+varlen_non_empty_sentinel || varlen_body(bytes)
+```
+
+For UTF-8, `bytes` are the UTF-8 bytes of the string. For binary, `bytes` are the raw binary
+bytes. The byte ordering is therefore UTF-8 byte lexicographic order for strings and raw byte
+lexicographic order for binary.
+
+### Variable-Length Body
+
+Non-empty variable-length values are encoded in blocks. Each block contains 32 data bytes
+followed by one marker byte:
+
+```text
+data[0..32] || marker
+```
+
+For ascending order:
+
+- Every non-final full block uses marker `0xFF`.
+- The final block is padded with zeros to 32 data bytes.
+- The final marker is the number of real data bytes in the final block, in `1..=32`.
+
+For descending order:
+
+- Every data byte is inverted.
+- Every non-final full-block marker is `0x00`, the inverse of `0xFF`.
+- The final block is padded with `0xFF`, the inverse of ascending zero padding.
+- The final marker is inverted: `final_len XOR 0xFF`.
+
+If the input length is exactly a multiple of 32, the final block has marker `32`, and earlier
+blocks, if any, use the continuation marker.
+
+This block structure preserves prefix order. For example, in ascending order a shorter value
+that is a prefix of a longer value reaches its final marker before the longer value reaches
+the continuation marker. Since final length markers in `1..=32` are less than `0xFF`, the
+shorter prefix sorts first. Descending order inverts the same bytes and reverses that result.
+
+## Struct
+
+A struct is encoded as:
+
+```text
+struct_sentinel || field_0 || field_1 || ... || field_n
+```
+
+The outer sentinel is the fixed-width sentinel:
+
+- `0x01` for a non-null struct
+- `0x00` or `0x02` for a null struct, depending on null placement
+
+For a non-null struct, each field is encoded recursively in schema order using the same
+`RowSortField` as the parent struct column.
+
+For a null struct, the body is canonicalized so two null parent rows produce byte-equal
+output even if their physical child arrays contain different values:
+
+- Fixed-width children contribute their fixed-width null encoding.
+- Variable-width children contribute exactly one child null sentinel byte.
+
+A struct has fixed row width only when all of its fields have fixed row width. If any child
+is variable-width, the struct is variable-width.
+
+## Fixed-Size List
+
+A fixed-size list with `N` elements is encoded as:
+
+```text
+list_sentinel || element_0 || element_1 || ... || element_N-1
+```
+
+The outer sentinel is the fixed-width sentinel:
+
+- `0x01` for a non-null list
+- `0x00` or `0x02` for a null list, depending on null placement
+
+For a non-null fixed-size list, elements are encoded recursively in element order using the
+same `RowSortField` as the parent list column.
+
+For a null fixed-size list, the body is canonicalized:
+
+- Fixed-width elements contribute their fixed-width null encoding, repeated `N` times.
+- Variable-width elements contribute one child null sentinel byte per element.
+
+A fixed-size list has fixed row width only when its element type has fixed row width.
+
+## Nested Values
+
+Nested structs and fixed-size lists apply the same rules recursively. Each nullable parent
+adds its own outer sentinel. Null parents canonicalize their child body before comparison can
+observe underlying child values.
+
+## Unsupported Types
+
+The current row encoder rejects types for which it does not define byte-sort semantics:
+
+| Type | Reason |
+| --- | --- |
+| Variable-size `List` | No row encoding order is defined. |
+| `Variant` | No row encoding order is defined. |
+| `Union` | No row encoding order is defined. |
+| `Extension` | No row encoding order is defined. |
+| `Decimal256` | Encoding is not implemented. |
+
+The absence of these encodings is intentional. Adding one requires defining both the logical
+ordering and the exact byte representation that preserves that ordering.
+
+Temporal extensions could be added later by normalizing them to storage arrays at the
+row-encoder boundary, once the supported temporal ordering contract is made explicit.
+
+## Size and Output Layout
+
+The encoded output is a `ListView<u8>`:
+
+```text
+elements: contiguous u8 buffer containing all row bytes
+offsets:  per-row start offset into elements
+sizes:    per-row byte length
+```
+
+Rows are not self-describing without their `sizes`. A variable-width field can make one row
+longer than another, and the enclosing `ListView` supplies the row boundary.
+
+The encoder computes sizes before writing bytes:
+
+- Fixed-width columns contribute a constant width per row.
+- Variable-width columns contribute data-dependent widths per row.
+- The final `sizes` array is also used as the per-row write cursor during encoding.
+
+## Why Concatenation Works
+
+For each supported field type, the field encoder is an order embedding from logical values to
+byte strings:
+
+```text
+a < b  <=>  encode_field(a) < encode_field(b)
+a = b  <=>  encode_field(a) = encode_field(b)
+```
+
+When two rows are compared lexicographically, the first differing byte belongs to the first
+field whose encoded value differs. All preceding fields have byte-equal encodings and
+therefore equal logical values. The result is the same as tuple comparison.
+
+Variable-width fields preserve this property because their encodings are self-delimiting for
+comparison:
+
+- Null, empty, and non-empty values differ at the first byte.
+- Non-empty values use block markers to decide prefix cases before the next field can be
+  compared.
+- Row boundaries are supplied by `ListView` sizes.
+
+Descending order works because complementing every byte of an equal-length order-preserving
+value encoding reverses its order. The variable-width encoding also complements its sentinels,
+body bytes, padding, and markers for non-null values, so the same reversal applies to strings
+and binary values. Null sentinels are excluded from that reversal so null placement remains
+controlled solely by `nulls_first`.
+
+## Example Row
+
+This example shows one row that contains every supported encoding family. All columns use
+ascending order with nulls first.
+
+Schema:
+
+```text
+(
+    null_col: Null,
+    bool_col: Bool,
+    uint_col: U16,
+    int_col: I16,
+    float_col: F32,
+    decimal_col: Decimal(precision = 9, scale = 2),
+    utf8_col: Utf8,
+    binary_col: Binary,
+    struct_col: Struct { x: I8, y: Utf8 },
+    fsl_col: FixedSizeList<U8, 3>,
+)
+```
+
+Values:
+
+```text
+(
+    null,
+    true,
+    258_u16,
+    -5_i16,
+    1.5_f32,
+    123.45_decimal,     // stored as 12345_i32
+    "a",
+    DE AD BE EF,
+    { x: 1_i8, y: "" },
+    [1_u8, 2_u8, 3_u8],
+)
+```
+
+Encoded columns:
+
+| Column | Encoded bytes |
+| --- | --- |
+| `null_col` | `00` |
+| `bool_col` | `01 02` |
+| `uint_col` | `01 01 02` |
+| `int_col` | `01 7F FB` |
+| `float_col` | `01 BF C0 00 00` |
+| `decimal_col` | `01 80 00 30 39` |
+| `utf8_col` | `02 61 zero(31) 01` |
+| `binary_col` | `02 DE AD BE EF zero(28) 04` |
+| `struct_col` | `01 01 81 01` |
+| `fsl_col` | `01 01 01 01 02 01 03` |
+
+The full row key is the concatenation of those byte strings in schema order:
+
+```text
+00
+|| 01 02
+|| 01 01 02
+|| 01 7F FB
+|| 01 BF C0 00 00
+|| 01 80 00 30 39
+|| 02 61 zero(31) 01
+|| 02 DE AD BE EF zero(28) 04
+|| 01 01 81 01
+|| 01 01 01 01 02 01 03
+```
+
+Primitive examples here use one representative width per primitive family. Other widths use
+the same transform and emit exactly `width(T)` value bytes.
diff --git a/encodings/alp/benches/alp_compress.rs b/encodings/alp/benches/alp_compress.rs
index 7fbe60d5997..70a566ab0f8 100644
--- a/encodings/alp/benches/alp_compress.rs
+++ b/encodings/alp/benches/alp_compress.rs
@@ -3,6 +3,8 @@
 
 #![expect(clippy::unwrap_used)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use rand::RngExt;
 use rand::SeedableRng as _;
@@ -14,13 +16,14 @@ use vortex_alp::alp_encode;
 use vortex_alp::decompress_into_array;
 use vortex_array::Canonical;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::dtype::NativePType;
+use vortex_array::session::ArraySession;
 use vortex_array::validity::Validity;
 use vortex_buffer::Buffer;
 use vortex_buffer::buffer;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
@@ -48,6 +51,9 @@ const BENCH_ARGS: &[(usize, f64, f64)] = &[
     (10_000, 0.1, 1.0),
 ];
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 #[divan::bench(types = [f32, f64], args = BENCH_ARGS)]
 fn compress_alp<T: ALPFloat + NativePType>(bencher: Bencher, args: (usize, f64, f64)) {
     let (n, fraction_patch, fraction_valid) = args;
@@ -68,14 +74,9 @@ fn compress_alp<T: ALPFloat + NativePType>(bencher: Bencher, args: (usize, f64,
     let values = values.freeze();
     let array = PrimitiveArray::new(values, validity);
 
-    bencher.with_inputs(|| &array).bench_values(|array| {
-        alp_encode(
-            array.as_view(),
-            None,
-            &mut LEGACY_SESSION.create_execution_ctx(),
-        )
-        .unwrap()
-    })
+    bencher
+        .with_inputs(|| (&array, SESSION.create_execution_ctx()))
+        .bench_values(|(array, mut ctx)| alp_encode(array.as_view(), None, &mut ctx).unwrap())
 }
 
 #[divan::bench(types = [f32, f64], args = BENCH_ARGS)]
@@ -102,10 +103,10 @@ fn decompress_alp<T: ALPFloat + NativePType>(bencher: Bencher, args: (usize, f64
                 alp_encode(
                     PrimitiveArray::new(Buffer::copy_from(&values), validity.clone()).as_view(),
                     None,
-                    &mut LEGACY_SESSION.create_execution_ctx(),
+                    &mut SESSION.create_execution_ctx(),
                 )
                 .unwrap(),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_values(|(v, mut ctx)| decompress_into_array(v, &mut ctx));
@@ -143,7 +144,7 @@ fn compress_rd<T: ALPRDFloat + NativePType>(bencher: Bencher, args: (usize, f64)
     let encoder = RDEncoder::new(primitive.as_slice::<T>());
 
     bencher
-        .with_inputs(|| (&primitive, &encoder, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&primitive, &encoder, SESSION.create_execution_ctx()))
         .bench_refs(|(primitive, encoder, ctx)| encoder.encode(primitive.as_view(), ctx))
 }
 
@@ -152,12 +153,9 @@ fn decompress_rd<T: ALPRDFloat + NativePType>(bencher: Bencher, args: (usize, f6
     let (n, fraction_patch) = args;
     let primitive = make_rd_array::<T>(n, fraction_patch);
     let encoder = RDEncoder::new(primitive.as_slice::<T>());
-    let encoded = encoder.encode(
-        primitive.as_view(),
-        &mut LEGACY_SESSION.create_execution_ctx(),
-    );
+    let encoded = encoder.encode(primitive.as_view(), &mut SESSION.create_execution_ctx());
 
     bencher
-        .with_inputs(|| (&encoded, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&encoded, SESSION.create_execution_ctx()))
         .bench_refs(|(encoded, ctx)| (**encoded).clone().into_array().execute::<Canonical>(ctx));
 }
diff --git a/encodings/alp/src/alp/array.rs b/encodings/alp/src/alp/array.rs
index cac93d1d27d..3f7c2ca3e6d 100644
--- a/encodings/alp/src/alp/array.rs
+++ b/encodings/alp/src/alp/array.rs
@@ -16,10 +16,10 @@ use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
 use vortex_array::ArraySlots;
 use vortex_array::ArrayView;
+use vortex_array::EqMode;
 use vortex_array::ExecutionCtx;
 use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
-use vortex_array::Precision;
 use vortex_array::TypedArrayRef;
 use vortex_array::array_slots;
 use vortex_array::arrays::Primitive;
@@ -55,14 +55,14 @@ use crate::alp::rules::RULES;
 pub type ALPArray = Array<ALP>;
 
 impl ArrayHash for ALPData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _accuracy: EqMode) {
         self.exponents.hash(state);
         self.patches_data.hash(state);
     }
 }
 
 impl ArrayEq for ALPData {
-    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, _accuracy: EqMode) -> bool {
         self.exponents == other.exponents && self.patches_data == other.patches_data
     }
 }
@@ -695,22 +695,15 @@ mod tests {
             })
             .collect();
 
+        let mut ctx = SESSION.create_execution_ctx();
         let array = PrimitiveArray::from_option_iter(values.clone());
-        let encoded = alp_encode(
-            array.as_view(),
-            None,
-            &mut LEGACY_SESSION.create_execution_ctx(),
-        )
-        .unwrap();
+        let encoded = alp_encode(array.as_view(), None, &mut ctx).unwrap();
 
         let slice_end = size - slice_start;
         let slice_len = slice_end - slice_start;
         let sliced_encoded = encoded.slice(slice_start..slice_end).unwrap();
 
-        let result_canonical = {
-            let mut ctx = SESSION.create_execution_ctx();
-            sliced_encoded.execute::<Canonical>(&mut ctx).unwrap()
-        };
+        let result_canonical = sliced_encoded.execute::<Canonical>(&mut ctx).unwrap();
         let result_primitive = result_canonical.into_primitive();
 
         for idx in 0..slice_len {
@@ -719,7 +712,7 @@ mod tests {
             let result_valid = result_primitive
                 .validity()
                 .vortex_expect("result validity should be derivable")
-                .is_valid(idx)
+                .execute_is_valid(idx, &mut ctx)
                 .unwrap();
             assert_eq!(
                 result_valid,
diff --git a/encodings/alp/src/alp_rd/array.rs b/encodings/alp/src/alp_rd/array.rs
index 099b9e1a3ea..eaf98851665 100644
--- a/encodings/alp/src/alp_rd/array.rs
+++ b/encodings/alp/src/alp_rd/array.rs
@@ -18,11 +18,11 @@ use vortex_array::ArrayRef;
 use vortex_array::ArraySlots;
 use vortex_array::ArrayView;
 use vortex_array::Canonical;
+use vortex_array::EqMode;
 use vortex_array::ExecutionCtx;
 use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::LEGACY_SESSION;
-use vortex_array::Precision;
 use vortex_array::TypedArrayRef;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::Primitive;
@@ -75,17 +75,17 @@ pub struct ALPRDMetadata {
 }
 
 impl ArrayHash for ALPRDData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
-        self.left_parts_dictionary.array_hash(state, precision);
+    fn array_hash<H: Hasher>(&self, state: &mut H, accuracy: EqMode) {
+        self.left_parts_dictionary.array_hash(state, accuracy);
         self.right_bit_width.hash(state);
         self.patches_data.hash(state);
     }
 }
 
 impl ArrayEq for ALPRDData {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, accuracy: EqMode) -> bool {
         self.left_parts_dictionary
-            .array_eq(&other.left_parts_dictionary, precision)
+            .array_eq(&other.left_parts_dictionary, accuracy)
             && self.right_bit_width == other.right_bit_width
             && self.patches_data == other.patches_data
     }
diff --git a/encodings/bytebool/src/array.rs b/encodings/bytebool/src/array.rs
index 40da3809d01..722f48f7376 100644
--- a/encodings/bytebool/src/array.rs
+++ b/encodings/bytebool/src/array.rs
@@ -14,10 +14,10 @@ use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
 use vortex_array::ArraySlots;
 use vortex_array::ArrayView;
+use vortex_array::EqMode;
 use vortex_array::ExecutionCtx;
 use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
-use vortex_array::Precision;
 use vortex_array::TypedArrayRef;
 use vortex_array::arrays::BoolArray;
 use vortex_array::buffer::BufferHandle;
@@ -45,14 +45,14 @@ use crate::kernel::PARENT_KERNELS;
 pub type ByteBoolArray = Array<ByteBool>;
 
 impl ArrayHash for ByteBoolData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
-        self.buffer.array_hash(state, precision);
+    fn array_hash<H: Hasher>(&self, state: &mut H, accuracy: EqMode) {
+        self.buffer.array_hash(state, accuracy);
     }
 }
 
 impl ArrayEq for ByteBoolData {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
-        self.buffer.array_eq(&other.buffer, precision)
+    fn array_eq(&self, other: &Self, accuracy: EqMode) -> bool {
+        self.buffer.array_eq(&other.buffer, accuracy)
     }
 }
 
diff --git a/encodings/datetime-parts/src/array.rs b/encodings/datetime-parts/src/array.rs
index e603b1ddfe5..ddc5ee52981 100644
--- a/encodings/datetime-parts/src/array.rs
+++ b/encodings/datetime-parts/src/array.rs
@@ -15,10 +15,10 @@ use vortex_array::ArrayId;
 use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
 use vortex_array::ArrayView;
+use vortex_array::EqMode;
 use vortex_array::ExecutionCtx;
 use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
-use vortex_array::Precision;
 use vortex_array::array_slots;
 use vortex_array::arrays::Primitive;
 use vortex_array::arrays::TemporalArray;
@@ -50,11 +50,11 @@ use crate::split_temporal;
 pub type DateTimePartsArray = Array<DateTimeParts>;
 
 impl ArrayHash for DateTimePartsData {
-    fn array_hash<H: Hasher>(&self, _state: &mut H, _precision: Precision) {}
+    fn array_hash<H: Hasher>(&self, _state: &mut H, _accuracy: EqMode) {}
 }
 
 impl ArrayEq for DateTimePartsData {
-    fn array_eq(&self, _other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, _other: &Self, _accuracy: EqMode) -> bool {
         true
     }
 }
diff --git a/encodings/datetime-parts/src/canonical.rs b/encodings/datetime-parts/src/canonical.rs
index 78dc8e689c1..3a46eb6f328 100644
--- a/encodings/datetime-parts/src/canonical.rs
+++ b/encodings/datetime-parts/src/canonical.rs
@@ -143,12 +143,11 @@ mod test {
             &mut ctx,
         )?;
 
-        assert!(
-            date_times
-                .as_array()
-                .validity()?
-                .mask_eq(&validity, &mut ctx)?
-        );
+        assert!(date_times.as_array().validity()?.mask_eq(
+            &validity,
+            milliseconds.len(),
+            &mut ctx
+        )?);
 
         let dtype = date_times.dtype().clone();
         let parts = DateTimePartsParts {
@@ -163,7 +162,6 @@ mod test {
             .execute::<PrimitiveArray>(&mut ctx)?;
 
         assert_arrays_eq!(primitive_values, milliseconds);
-        assert!(primitive_values.validity()?.mask_eq(&validity, &mut ctx)?);
         Ok(())
     }
 }
diff --git a/encodings/datetime-parts/src/compress.rs b/encodings/datetime-parts/src/compress.rs
index 676e7bbfd43..6caf3c9f643 100644
--- a/encodings/datetime-parts/src/compress.rs
+++ b/encodings/datetime-parts/src/compress.rs
@@ -103,7 +103,7 @@ mod tests {
             days_prim
                 .validity()
                 .vortex_expect("days validity should be derivable")
-                .mask_eq(&validity, &mut ctx)
+                .mask_eq(&validity, days_prim.len(), &mut ctx)
                 .unwrap()
         );
         let seconds_prim = seconds.execute::<PrimitiveArray>(&mut ctx).unwrap();
diff --git a/encodings/datetime-parts/src/compute/compare.rs b/encodings/datetime-parts/src/compute/compare.rs
index faecc8452b3..9f854b0e0f9 100644
--- a/encodings/datetime-parts/src/compute/compare.rs
+++ b/encodings/datetime-parts/src/compute/compare.rs
@@ -202,8 +202,11 @@ fn compare_dtp(
 #[cfg(test)]
 mod test {
     use rstest::rstest;
+    use vortex_array::ArrayRef;
+    use vortex_array::ExecutionCtx;
     use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::aggregate_fn::fns::sum::sum;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::TemporalArray;
     use vortex_array::dtype::IntegerPType;
@@ -230,12 +233,22 @@ mod test {
         .expect("Failed to construct DateTimePartsArray from TemporalArray")
     }
 
+    /// Count the true values in a boolean array using the provided execution context.
+    fn true_count(array: &ArrayRef, ctx: &mut ExecutionCtx) -> usize {
+        sum(array, ctx)
+            .unwrap()
+            .as_primitive()
+            .as_::<usize>()
+            .unwrap()
+    }
+
     #[rstest]
     #[case(Validity::NonNullable, Validity::NonNullable)]
     #[case(Validity::NonNullable, Validity::AllValid)]
     #[case(Validity::AllValid, Validity::NonNullable)]
     #[case(Validity::AllValid, Validity::AllValid)]
     fn compare_date_time_parts_eq(#[case] lhs_validity: Validity, #[case] rhs_validity: Validity) {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let lhs = dtp_array_from_timestamp(86400i64, lhs_validity); // January 2, 1970, 00:00:00 UTC
         let rhs = dtp_array_from_timestamp(86400i64, rhs_validity.clone()); // January 2, 1970, 00:00:00 UTC
         let comparison = lhs
@@ -243,14 +256,14 @@ mod test {
             .into_array()
             .binary(rhs.into_array(), Operator::Eq)
             .unwrap();
-        assert_eq!(comparison.as_bool_typed().true_count().unwrap(), 1);
+        assert_eq!(true_count(&comparison, &mut ctx), 1);
 
         let rhs = dtp_array_from_timestamp(0i64, rhs_validity); // January 1, 1970, 00:00:00 UTC
         let comparison = lhs
             .into_array()
             .binary(rhs.into_array(), Operator::Eq)
             .unwrap();
-        assert_eq!(comparison.as_bool_typed().true_count().unwrap(), 0);
+        assert_eq!(true_count(&comparison, &mut ctx), 0);
     }
 
     #[rstest]
@@ -259,6 +272,7 @@ mod test {
     #[case(Validity::AllValid, Validity::NonNullable)]
     #[case(Validity::AllValid, Validity::AllValid)]
     fn compare_date_time_parts_ne(#[case] lhs_validity: Validity, #[case] rhs_validity: Validity) {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let lhs = dtp_array_from_timestamp(86400i64, lhs_validity); // January 2, 1970, 00:00:00 UTC
         let rhs = dtp_array_from_timestamp(86401i64, rhs_validity.clone()); // January 2, 1970, 00:00:01 UTC
         let comparison = lhs
@@ -266,14 +280,14 @@ mod test {
             .into_array()
             .binary(rhs.into_array(), Operator::NotEq)
             .unwrap();
-        assert_eq!(comparison.as_bool_typed().true_count().unwrap(), 1);
+        assert_eq!(true_count(&comparison, &mut ctx), 1);
 
         let rhs = dtp_array_from_timestamp(86400i64, rhs_validity); // January 2, 1970, 00:00:00 UTC
         let comparison = lhs
             .into_array()
             .binary(rhs.into_array(), Operator::NotEq)
             .unwrap();
-        assert_eq!(comparison.as_bool_typed().true_count().unwrap(), 0);
+        assert_eq!(true_count(&comparison, &mut ctx), 0);
     }
 
     #[rstest]
@@ -282,6 +296,7 @@ mod test {
     #[case(Validity::AllValid, Validity::NonNullable)]
     #[case(Validity::AllValid, Validity::AllValid)]
     fn compare_date_time_parts_lt(#[case] lhs_validity: Validity, #[case] rhs_validity: Validity) {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let lhs = dtp_array_from_timestamp(0i64, lhs_validity); // January 1, 1970, 01:00:00 UTC
         let rhs = dtp_array_from_timestamp(86400i64, rhs_validity); // January 2, 1970, 00:00:00 UTC
 
@@ -289,7 +304,7 @@ mod test {
             .into_array()
             .binary(rhs.into_array(), Operator::Lt)
             .unwrap();
-        assert_eq!(comparison.as_bool_typed().true_count().unwrap(), 1);
+        assert_eq!(true_count(&comparison, &mut ctx), 1);
     }
 
     #[rstest]
@@ -298,6 +313,7 @@ mod test {
     #[case(Validity::AllValid, Validity::NonNullable)]
     #[case(Validity::AllValid, Validity::AllValid)]
     fn compare_date_time_parts_gt(#[case] lhs_validity: Validity, #[case] rhs_validity: Validity) {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let lhs = dtp_array_from_timestamp(86400i64, lhs_validity); // January 2, 1970, 02:00:00 UTC
         let rhs = dtp_array_from_timestamp(0i64, rhs_validity); // January 1, 1970, 01:00:00 UTC
 
@@ -305,7 +321,7 @@ mod test {
             .into_array()
             .binary(rhs.into_array(), Operator::Gt)
             .unwrap();
-        assert_eq!(comparison.as_bool_typed().true_count().unwrap(), 1);
+        assert_eq!(true_count(&comparison, &mut ctx), 1);
     }
 
     #[rstest]
@@ -317,6 +333,7 @@ mod test {
         #[case] lhs_validity: Validity,
         #[case] rhs_validity: Validity,
     ) {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let temporal_array = TemporalArray::new_timestamp(
             PrimitiveArray::new(buffer![0i64], lhs_validity.clone()).into_array(),
             TimeUnit::Seconds,
@@ -339,27 +356,27 @@ mod test {
             .into_array()
             .binary(rhs.clone().into_array(), Operator::Eq)
             .unwrap();
-        assert_eq!(comparison.as_bool_typed().true_count().unwrap(), 0);
+        assert_eq!(true_count(&comparison, &mut ctx), 0);
 
         let comparison = lhs
             .clone()
             .into_array()
             .binary(rhs.clone().into_array(), Operator::NotEq)
             .unwrap();
-        assert_eq!(comparison.as_bool_typed().true_count().unwrap(), 1);
+        assert_eq!(true_count(&comparison, &mut ctx), 1);
 
         let comparison = lhs
             .clone()
             .into_array()
             .binary(rhs.clone().into_array(), Operator::Lt)
             .unwrap();
-        assert_eq!(comparison.as_bool_typed().true_count().unwrap(), 1);
+        assert_eq!(true_count(&comparison, &mut ctx), 1);
 
         let comparison = lhs
             .into_array()
             .binary(rhs.into_array(), Operator::Lte)
             .unwrap();
-        assert_eq!(comparison.as_bool_typed().true_count().unwrap(), 1);
+        assert_eq!(true_count(&comparison, &mut ctx), 1);
 
         // `CompareOperator::Gt` and `CompareOperator::Gte` only cover the case of all lhs values
         // being larger. Therefore, these cases are not covered by unit tests.
diff --git a/encodings/datetime-parts/src/compute/rules.rs b/encodings/datetime-parts/src/compute/rules.rs
index a8b1b2eca83..bba19ceea47 100644
--- a/encodings/datetime-parts/src/compute/rules.rs
+++ b/encodings/datetime-parts/src/compute/rules.rs
@@ -133,10 +133,9 @@ impl ArrayParentReduceRule<DateTimeParts> for DTPComparisonPushDownRule {
             }
         }
 
-        let result =
-            ScalarFnArray::try_new(parent.scalar_fn().clone(), new_children, parent.len())?
-                .into_array()
-                .optimize()?;
+        let result = ScalarFnArray::try_new(parent.scalar_fn().clone(), new_children)?
+            .into_array()
+            .optimize()?;
 
         Ok(Some(result))
     }
@@ -179,8 +178,11 @@ fn is_constant_zero(array: &ArrayRef) -> bool {
 
 #[cfg(test)]
 mod tests {
+    use vortex_array::ArrayRef;
+    use vortex_array::ExecutionCtx;
     use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::aggregate_fn::fns::sum::sum;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::TemporalArray;
     use vortex_array::arrays::scalar_fn::ScalarFnFactoryExt;
@@ -200,6 +202,15 @@ mod tests {
 
     const SECONDS_PER_DAY: i64 = 86400;
 
+    /// Count the true values in a boolean array using the provided execution context.
+    fn true_count(array: &ArrayRef, ctx: &mut ExecutionCtx) -> usize {
+        sum(array, ctx)
+            .unwrap()
+            .as_primitive()
+            .as_::<usize>()
+            .unwrap()
+    }
+
     /// Create a DTP array with the given day values (all at midnight).
     fn dtp_at_midnight(days: &[i64], time_unit: TimeUnit) -> DateTimePartsArray {
         let multiplier = match time_unit {
@@ -285,7 +296,8 @@ mod tests {
         );
 
         // Verify correctness: days [0, 1, 2] <= 1 should give [true, true, false]
-        assert_eq!(optimized.as_bool_typed().true_count().unwrap(), 2);
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(true_count(&optimized, &mut ctx), 2);
     }
 
     #[test]
@@ -313,7 +325,8 @@ mod tests {
         let optimized = between.optimize().unwrap();
 
         // Verify correctness: days [0, 1, 2, 3, 4] between 1 and 3 should give [false, true, true, true, false]
-        assert_eq!(optimized.as_bool_typed().true_count().unwrap(), 3);
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(true_count(&optimized, &mut ctx), 3);
     }
 
     #[test]
@@ -335,7 +348,8 @@ mod tests {
         // (optimization doesn't apply, so we keep the original structure)
         // Just verify it still computes correctly
         // days [0, 1, 2] at midnight <= day 1 at noon: [true, true, false]
-        assert_eq!(optimized.as_bool_typed().true_count().unwrap(), 2);
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(true_count(&optimized, &mut ctx), 2);
     }
 
     #[test]
@@ -352,9 +366,8 @@ mod tests {
             TimeUnit::Seconds,
             None,
         );
-        let dtp =
-            DateTimeParts::try_from_temporal(temporal, &mut LEGACY_SESSION.create_execution_ctx())
-                .unwrap();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let dtp = DateTimeParts::try_from_temporal(temporal, &mut ctx).unwrap();
         let len = dtp.len();
 
         // Compare against midnight constant
@@ -366,6 +379,6 @@ mod tests {
         // Should still compute correctly (just not optimized via pushdown)
         let optimized = comparison.optimize().unwrap();
         // timestamps at 1am on days [0, 1, 2] <= day 1 midnight: [true, false, false]
-        assert_eq!(optimized.as_bool_typed().true_count().unwrap(), 1);
+        assert_eq!(true_count(&optimized, &mut ctx), 1);
     }
 }
diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs
index 76349f40910..42135a9ecaa 100644
--- a/encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs
+++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs
@@ -17,10 +17,10 @@ use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
 use vortex_array::ArrayId;
 use vortex_array::ArrayRef;
+use vortex_array::EqMode;
 use vortex_array::ExecutionCtx;
 use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
-use vortex_array::Precision;
 use vortex_array::TypedArrayRef;
 use vortex_array::arrays::DecimalArray;
 use vortex_array::arrays::PrimitiveArray;
@@ -53,11 +53,11 @@ use crate::decimal_byte_parts::rules::PARENT_RULES;
 pub type DecimalBytePartsArray = Array<DecimalByteParts>;
 
 impl ArrayHash for DecimalBytePartsData {
-    fn array_hash<H: Hasher>(&self, _state: &mut H, _precision: Precision) {}
+    fn array_hash<H: Hasher>(&self, _state: &mut H, _accuracy: EqMode) {}
 }
 
 impl ArrayEq for DecimalBytePartsData {
-    fn array_eq(&self, _other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, _other: &Self, _accuracy: EqMode) -> bool {
         true
     }
 }
diff --git a/encodings/experimental/onpair/benches/decode.rs b/encodings/experimental/onpair/benches/decode.rs
index 2f3fce9db23..ff8db8c22c2 100644
--- a/encodings/experimental/onpair/benches/decode.rs
+++ b/encodings/experimental/onpair/benches/decode.rs
@@ -213,9 +213,8 @@ fn canonicalize_to_varbinview(bencher: Bencher, case: (Shape, usize)) {
     let (shape, n) = case;
     let arr = compress(n, shape);
     bencher
-        .with_inputs(|| arr.clone().into_array())
-        .bench_local_values(|arr| {
-            let mut ctx = SESSION.create_execution_ctx();
+        .with_inputs(|| (arr.clone().into_array(), SESSION.create_execution_ctx()))
+        .bench_local_values(|(arr, mut ctx)| {
             divan::black_box(
                 arr.execute::<VarBinViewArray>(&mut ctx)
                     .unwrap_or_else(|e| panic!("canonicalize failed: {e}")),
@@ -234,13 +233,14 @@ fn filter_share_dict(bencher: Bencher, case: (Shape, usize)) {
     let (shape, n) = case;
     let arr = compress(n, shape);
     let mask = Mask::from_iter((0..n).map(|i| i % 7 == 0));
-    bencher.bench_local(|| {
-        let mut ctx = SESSION.create_execution_ctx();
-        let result = <OnPair as FilterKernel>::filter(arr.as_view(), &mask, &mut ctx)
-            .unwrap()
-            .unwrap();
-        divan::black_box(result);
-    });
+    bencher
+        .with_inputs(|| SESSION.create_execution_ctx())
+        .bench_local_values(|mut ctx| {
+            let result = <OnPair as FilterKernel>::filter(arr.as_view(), &mask, &mut ctx)
+                .unwrap()
+                .unwrap();
+            divan::black_box(result);
+        });
 }
 
 fn main() {
diff --git a/encodings/experimental/onpair/src/array.rs b/encodings/experimental/onpair/src/array.rs
index 18fa5e942ce..f9e18c36ac4 100644
--- a/encodings/experimental/onpair/src/array.rs
+++ b/encodings/experimental/onpair/src/array.rs
@@ -15,10 +15,10 @@ use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
 use vortex_array::ArrayView;
 use vortex_array::Canonical;
+use vortex_array::EqMode;
 use vortex_array::ExecutionCtx;
 use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
-use vortex_array::Precision;
 use vortex_array::array_slots;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::builders::ArrayBuilder;
@@ -196,19 +196,19 @@ impl Debug for OnPairData {
 }
 
 impl ArrayHash for OnPairData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
-        self.dict_bytes.as_host().array_hash(state, precision);
+    fn array_hash<H: Hasher>(&self, state: &mut H, accuracy: EqMode) {
+        self.dict_bytes.as_host().array_hash(state, accuracy);
         state.write_u32(self.bits);
     }
 }
 
 impl ArrayEq for OnPairData {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, accuracy: EqMode) -> bool {
         self.bits == other.bits
             && self
                 .dict_bytes
                 .as_host()
-                .array_eq(other.dict_bytes.as_host(), precision)
+                .array_eq(other.dict_bytes.as_host(), accuracy)
     }
 }
 
diff --git a/encodings/experimental/onpair/src/canonical.rs b/encodings/experimental/onpair/src/canonical.rs
index c658b841155..20a058e7f90 100644
--- a/encodings/experimental/onpair/src/canonical.rs
+++ b/encodings/experimental/onpair/src/canonical.rs
@@ -3,6 +3,8 @@
 //
 //! Convert an [`OnPairArray`] to its canonical `VarBinViewArray` by handing
 //! the materialised parts to `onpair::decompress_into`.
+//!
+//! [`OnPairArray`]: crate::OnPairArray
 
 use std::sync::Arc;
 
diff --git a/encodings/experimental/onpair/src/decode.rs b/encodings/experimental/onpair/src/decode.rs
index e3c7346f0d9..fd0b02b0284 100644
--- a/encodings/experimental/onpair/src/decode.rs
+++ b/encodings/experimental/onpair/src/decode.rs
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 //
-//! Helpers for turning [`OnPair`] slot children into the inputs the upstream
+//! Helpers for turning [`OnPair`](super::OnPair) slot children into the inputs the upstream
 //! `onpair` decoder consumes.
 
 use vortex_array::ArrayRef;
diff --git a/encodings/experimental/onpair/tests/big_data.rs b/encodings/experimental/onpair/tests/big_data.rs
index 81b1fa9e10b..c6bc163ea9f 100644
--- a/encodings/experimental/onpair/tests/big_data.rs
+++ b/encodings/experimental/onpair/tests/big_data.rs
@@ -18,6 +18,7 @@ use std::time::Instant;
 use vortex_array::IntoArray;
 use vortex_array::VortexSessionExecute;
 use vortex_array::accessor::ArrayAccessor;
+use vortex_array::aggregate_fn::fns::sum::sum;
 use vortex_array::arrays::ConstantArray;
 use vortex_array::arrays::VarBinArray;
 use vortex_array::arrays::VarBinViewArray;
@@ -121,6 +122,11 @@ fn smoke_100k_rows() {
         .execute::<vortex_array::Canonical>(&mut ctx)
         .unwrap()
         .into_array();
-    assert_eq!(eq.as_bool_typed().true_count().unwrap(), want_eq);
+    let eq_count = sum(&eq, &mut ctx)
+        .unwrap()
+        .as_primitive()
+        .as_::<usize>()
+        .unwrap();
+    assert_eq!(eq_count, want_eq);
     eprintln!("eq pushdown matches reference count ({})", want_eq);
 }
diff --git a/encodings/fastlanes/Cargo.toml b/encodings/fastlanes/Cargo.toml
index 08c96c481d7..e0aa5cbb724 100644
--- a/encodings/fastlanes/Cargo.toml
+++ b/encodings/fastlanes/Cargo.toml
@@ -64,6 +64,10 @@ required-features = ["_test-harness"]
 name = "bitpack_compare"
 harness = false
 
+[[bench]]
+name = "bitpack_compare_sweep"
+harness = false
+
 [[bench]]
 name = "cast_bitpacked"
 harness = false
diff --git a/encodings/fastlanes/benches/bitpack_compare.rs b/encodings/fastlanes/benches/bitpack_compare.rs
index 939c401ee38..c704f2b35ed 100644
--- a/encodings/fastlanes/benches/bitpack_compare.rs
+++ b/encodings/fastlanes/benches/bitpack_compare.rs
@@ -10,33 +10,39 @@
 #![expect(clippy::unwrap_used)]
 #![expect(clippy::cast_possible_truncation)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use divan::counter::ItemsCount;
 use vortex_array::ArrayRef;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::BoolArray;
 use vortex_array::arrays::ConstantArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::scalar_fn::fns::operators::Operator;
+use vortex_array::session::ArraySession;
 use vortex_array::validity::Validity;
 use vortex_buffer::BufferMut;
 use vortex_fastlanes::BitPackedData;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
 }
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 const LENS: &[usize] = &[1024, 64 * 1024];
 const BIT_WIDTHS: &[u8] = &[4, 16];
 
 /// Build a packed array of varied in-range values, plus an out-of-range constant RHS for
 /// the fast-path benches.
 fn build_inputs<const BW: u8>(len: usize) -> (ArrayRef, ArrayRef, ExecutionCtx) {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = SESSION.create_execution_ctx();
     let buf: BufferMut<u32> = (0..len).map(|i| (i as u32) % (1 << BW)).collect();
     let array = BitPackedData::encode(
         &PrimitiveArray::new(buf.freeze(), Validity::NonNullable).into_array(),
diff --git a/encodings/fastlanes/benches/bitpack_compare_sweep.rs b/encodings/fastlanes/benches/bitpack_compare_sweep.rs
new file mode 100644
index 00000000000..0be525566e7
--- /dev/null
+++ b/encodings/fastlanes/benches/bitpack_compare_sweep.rs
@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Sweeps the public `BitPackedArray` compare-against-constant path (`array.binary(rhs, op)`) over
+//! every integer type and every valid bit width, so a kernel change shows up as a CodSpeed diff.
+//!
+//! The array holds in-range values (no patches, no out-of-range fast path), so each iteration runs
+//! the full unpack + per-element compare kernel that backs `<BitPacked as CompareKernel>`.
+//!
+//! Run with `cargo bench -p vortex-fastlanes --bench bitpack_compare_sweep`.
+
+#![expect(clippy::unwrap_used)]
+#![expect(clippy::cast_possible_truncation)]
+
+use std::sync::LazyLock;
+
+use divan::Bencher;
+use divan::counter::ItemsCount;
+use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::BoolArray;
+use vortex_array::arrays::ConstantArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::builtins::ArrayBuiltins;
+use vortex_array::dtype::NativePType;
+use vortex_array::scalar::Scalar;
+use vortex_array::scalar_fn::fns::operators::Operator;
+use vortex_array::session::ArraySession;
+use vortex_array::validity::Validity;
+use vortex_buffer::BufferMut;
+use vortex_fastlanes::BitPackedData;
+use vortex_session::VortexSession;
+
+fn main() {
+    divan::main();
+}
+
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
+/// Number of elements per benchmarked array (64 full FastLanes blocks).
+const LEN: usize = 64 * 1024;
+
+/// Operator under test. `Lt` exercises the full unpack + per-element comparison path.
+const OP: Operator = Operator::Lt;
+
+/// Integer types we can build packed arrays for in the benchmark.
+trait BenchInt: NativePType + Copy + Into<Scalar> {
+    /// Build an in-range value from a small counter.
+    fn from_counter(v: u64) -> Self;
+}
+
+macro_rules! impl_bench_int {
+    ($($T:ty),+) => {
+        $(impl BenchInt for $T {
+            #[inline]
+            fn from_counter(v: u64) -> Self {
+                v as $T
+            }
+        })+
+    };
+}
+
+impl_bench_int!(u8, u16, u32, u64, i8, i16, i32, i64);
+
+/// Encode `LEN` in-range values of type `T` at the given bit width, returning the packed array, a
+/// mid-range constant to compare against, and an execution context.
+fn setup<T: BenchInt>(width: usize) -> (ArrayRef, ArrayRef, ExecutionCtx) {
+    let mut ctx = SESSION.create_execution_ctx();
+    let cap = 1u64 << width;
+    let buf: BufferMut<T> = (0..LEN)
+        .map(|i| T::from_counter((i as u64) % cap))
+        .collect();
+    let array = BitPackedData::encode(
+        &PrimitiveArray::new(buf.freeze(), Validity::NonNullable).into_array(),
+        width as u8,
+        &mut ctx,
+    )
+    .unwrap()
+    .into_array();
+    let rhs = ConstantArray::new(T::from_counter(cap / 2), LEN).into_array();
+    (array, rhs, ctx)
+}
+
+/// Generate a compare benchmark over every valid bit width for one type. Valid widths are
+/// `1..native_bits` - bit-packing requires the target width to be strictly narrower than the type.
+macro_rules! bench_type {
+    ($modname:ident, $T:ty, $native_bits:expr) => {
+        mod $modname {
+            use super::*;
+
+            #[divan::bench(args = 1..$native_bits)]
+            fn compare(bencher: Bencher, width: usize) {
+                let (array, rhs, mut ctx) = setup::<$T>(width);
+                bencher.counter(ItemsCount::new(LEN)).bench_local(|| {
+                    array
+                        .clone()
+                        .binary(rhs.clone(), OP)
+                        .unwrap()
+                        .execute::<BoolArray>(&mut ctx)
+                        .unwrap()
+                });
+            }
+        }
+    };
+}
+
+bench_type!(u8, u8, 8usize);
+bench_type!(u16, u16, 16usize);
+bench_type!(u32, u32, 32usize);
+bench_type!(u64, u64, 64usize);
+bench_type!(i8, i8, 8usize);
+bench_type!(i16, i16, 16usize);
+bench_type!(i32, i32, 32usize);
+bench_type!(i64, i64, 64usize);
diff --git a/encodings/fastlanes/benches/bitpacking_take.rs b/encodings/fastlanes/benches/bitpacking_take.rs
index a5a7803bcaf..2e01f1253e6 100644
--- a/encodings/fastlanes/benches/bitpacking_take.rs
+++ b/encodings/fastlanes/benches/bitpacking_take.rs
@@ -4,37 +4,42 @@
 #![expect(clippy::unwrap_used)]
 #![expect(clippy::cast_possible_truncation)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use rand::RngExt;
 use rand::SeedableRng;
 use rand::distr::Uniform;
 use rand::prelude::StdRng;
 use vortex_array::IntoArray as _;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::RecursiveCanonical;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::PrimitiveArray;
+use vortex_array::session::ArraySession;
 use vortex_array::validity::Validity;
 use vortex_buffer::Buffer;
 use vortex_buffer::buffer;
 use vortex_fastlanes::BitPackedArrayExt;
 use vortex_fastlanes::bitpack_compress::bitpack_to_best_bit_width;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
 }
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 #[divan::bench]
 fn take_10_stratified(bencher: Bencher) {
     let values = fixture(65_536, 8);
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed =
-        bitpack_to_best_bit_width(&uncompressed, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        bitpack_to_best_bit_width(&uncompressed, &mut SESSION.create_execution_ctx()).unwrap();
     let indices = PrimitiveArray::from_iter((0..10).map(|i| i * 6_553));
 
     bencher
-        .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&packed, &indices, SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
                 .take(indices.clone().into_array())
@@ -49,12 +54,11 @@ fn take_10_contiguous(bencher: Bencher) {
     let values = fixture(65_536, 8);
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed =
-        bitpack_to_best_bit_width(&uncompressed, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        bitpack_to_best_bit_width(&uncompressed, &mut SESSION.create_execution_ctx()).unwrap();
     let indices = buffer![0..10].into_array();
 
     bencher
-        .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&packed, &indices, SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
                 .take(indices.clone())
@@ -70,14 +74,13 @@ fn take_10k_random(bencher: Bencher) {
     let range = Uniform::new(0, values.len()).unwrap();
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed =
-        bitpack_to_best_bit_width(&uncompressed, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        bitpack_to_best_bit_width(&uncompressed, &mut SESSION.create_execution_ctx()).unwrap();
 
     let rng = StdRng::seed_from_u64(0);
     let indices = PrimitiveArray::from_iter(rng.sample_iter(range).take(10_000).map(|i| i as u32));
 
     bencher
-        .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&packed, &indices, SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
                 .take(indices.clone().into_array())
@@ -92,12 +95,11 @@ fn take_10k_contiguous(bencher: Bencher) {
     let values = fixture(65_536, 8);
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed =
-        bitpack_to_best_bit_width(&uncompressed, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        bitpack_to_best_bit_width(&uncompressed, &mut SESSION.create_execution_ctx()).unwrap();
     let indices = PrimitiveArray::from_iter(0..10_000);
 
     bencher
-        .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&packed, &indices, SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
                 .take(indices.clone().into_array())
@@ -112,12 +114,11 @@ fn take_10k_dispersed(bencher: Bencher) {
     let values = fixture(65_536, 8);
     let uncompressed = PrimitiveArray::new(values.clone(), Validity::NonNullable);
     let packed =
-        bitpack_to_best_bit_width(&uncompressed, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        bitpack_to_best_bit_width(&uncompressed, &mut SESSION.create_execution_ctx()).unwrap();
     let indices = PrimitiveArray::from_iter((0..10_000).map(|i| (i * 42) % values.len() as u64));
 
     bencher
-        .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&packed, &indices, SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
                 .take(indices.clone().into_array())
@@ -132,12 +133,11 @@ fn take_10k_first_chunk_only(bencher: Bencher) {
     let values = fixture(65_536, 8);
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed =
-        bitpack_to_best_bit_width(&uncompressed, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        bitpack_to_best_bit_width(&uncompressed, &mut SESSION.create_execution_ctx()).unwrap();
     let indices = PrimitiveArray::from_iter((0..10_000).map(|i| ((i * 42) % 1024) as u64));
 
     bencher
-        .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&packed, &indices, SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
                 .take(indices.clone().into_array())
@@ -172,8 +172,7 @@ fn patched_take_10_stratified(bencher: Bencher) {
     let values = (0u32..BIG_BASE2 + NUM_EXCEPTIONS).collect::<Buffer<u32>>();
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed =
-        bitpack_to_best_bit_width(&uncompressed, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        bitpack_to_best_bit_width(&uncompressed, &mut SESSION.create_execution_ctx()).unwrap();
 
     assert!(packed.patches().is_some());
     assert_eq!(
@@ -184,7 +183,7 @@ fn patched_take_10_stratified(bencher: Bencher) {
     let indices = PrimitiveArray::from_iter((0..10).map(|i| i * 6_653));
 
     bencher
-        .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&packed, &indices, SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
                 .take(indices.clone().into_array())
@@ -199,8 +198,7 @@ fn patched_take_10_contiguous(bencher: Bencher) {
     let values = (0u32..BIG_BASE2 + NUM_EXCEPTIONS).collect::<Buffer<u32>>();
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed =
-        bitpack_to_best_bit_width(&uncompressed, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        bitpack_to_best_bit_width(&uncompressed, &mut SESSION.create_execution_ctx()).unwrap();
 
     assert!(packed.patches().is_some());
     assert_eq!(
@@ -211,7 +209,7 @@ fn patched_take_10_contiguous(bencher: Bencher) {
     let indices = buffer![0..10].into_array();
 
     bencher
-        .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&packed, &indices, SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
                 .take(indices.clone())
@@ -226,15 +224,14 @@ fn patched_take_10k_random(bencher: Bencher) {
     let values = (0u32..BIG_BASE2 + NUM_EXCEPTIONS).collect::<Buffer<u32>>();
     let uncompressed = PrimitiveArray::new(values.clone(), Validity::NonNullable);
     let packed =
-        bitpack_to_best_bit_width(&uncompressed, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        bitpack_to_best_bit_width(&uncompressed, &mut SESSION.create_execution_ctx()).unwrap();
 
     let rng = StdRng::seed_from_u64(0);
     let range = Uniform::new(0, values.len()).unwrap();
     let indices = PrimitiveArray::from_iter(rng.sample_iter(range).take(10_000).map(|i| i as u32));
 
     bencher
-        .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&packed, &indices, SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
                 .take(indices.clone().into_array())
@@ -249,12 +246,11 @@ fn patched_take_10k_contiguous_not_patches(bencher: Bencher) {
     let values = (0u32..BIG_BASE2 + NUM_EXCEPTIONS).collect::<Buffer<u32>>();
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed =
-        bitpack_to_best_bit_width(&uncompressed, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        bitpack_to_best_bit_width(&uncompressed, &mut SESSION.create_execution_ctx()).unwrap();
     let indices = PrimitiveArray::from_iter((0u32..NUM_EXCEPTIONS).cycle().take(10000));
 
     bencher
-        .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&packed, &indices, SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
                 .take(indices.clone().into_array())
@@ -269,8 +265,7 @@ fn patched_take_10k_contiguous_patches(bencher: Bencher) {
     let values = (0u32..BIG_BASE2 + NUM_EXCEPTIONS).collect::<Buffer<u32>>();
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed =
-        bitpack_to_best_bit_width(&uncompressed, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        bitpack_to_best_bit_width(&uncompressed, &mut SESSION.create_execution_ctx()).unwrap();
 
     assert!(packed.patches().is_some());
     assert_eq!(
@@ -282,7 +277,7 @@ fn patched_take_10k_contiguous_patches(bencher: Bencher) {
         PrimitiveArray::from_iter((BIG_BASE2..BIG_BASE2 + NUM_EXCEPTIONS).cycle().take(10000));
 
     bencher
-        .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&packed, &indices, SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
                 .take(indices.clone().into_array())
@@ -297,12 +292,11 @@ fn patched_take_10k_dispersed(bencher: Bencher) {
     let values = (0u32..BIG_BASE2 + NUM_EXCEPTIONS).collect::<Buffer<u32>>();
     let uncompressed = PrimitiveArray::new(values.clone(), Validity::NonNullable);
     let packed =
-        bitpack_to_best_bit_width(&uncompressed, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        bitpack_to_best_bit_width(&uncompressed, &mut SESSION.create_execution_ctx()).unwrap();
     let indices = PrimitiveArray::from_iter((0..10_000).map(|i| (i * 42) % values.len() as u64));
 
     bencher
-        .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&packed, &indices, SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
                 .take(indices.clone().into_array())
@@ -317,12 +311,11 @@ fn patched_take_10k_first_chunk_only(bencher: Bencher) {
     let values = (0u32..BIG_BASE2 + NUM_EXCEPTIONS).collect::<Buffer<u32>>();
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed =
-        bitpack_to_best_bit_width(&uncompressed, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        bitpack_to_best_bit_width(&uncompressed, &mut SESSION.create_execution_ctx()).unwrap();
     let indices = PrimitiveArray::from_iter((0..10_000).map(|i| ((i * 42) % 1024) as u64));
 
     bencher
-        .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&packed, &indices, SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
                 .take(indices.clone().into_array())
@@ -337,8 +330,7 @@ fn patched_take_10k_adversarial(bencher: Bencher) {
     let values = (0u32..BIG_BASE2 + NUM_EXCEPTIONS).collect::<Buffer<u32>>();
     let uncompressed = PrimitiveArray::new(values, Validity::NonNullable);
     let packed =
-        bitpack_to_best_bit_width(&uncompressed, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        bitpack_to_best_bit_width(&uncompressed, &mut SESSION.create_execution_ctx()).unwrap();
     let per_chunk_count = 100;
     let indices = PrimitiveArray::from_iter(
         (0..(NUM_EXCEPTIONS + 1024) / 1024)
@@ -349,7 +341,7 @@ fn patched_take_10k_adversarial(bencher: Bencher) {
     );
 
     bencher
-        .with_inputs(|| (&packed, &indices, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&packed, &indices, SESSION.create_execution_ctx()))
         .bench_refs(|(packed, indices, execution_ctx)| {
             packed
                 .take(indices.clone().into_array())
diff --git a/encodings/fastlanes/benches/compute_between.rs b/encodings/fastlanes/benches/compute_between.rs
index 1630764ff8e..5a1bdcee655 100644
--- a/encodings/fastlanes/benches/compute_between.rs
+++ b/encodings/fastlanes/benches/compute_between.rs
@@ -2,6 +2,8 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 #![expect(clippy::unwrap_used)]
 
+use std::sync::LazyLock;
+
 use num_traits::NumCast;
 use rand::RngExt;
 use rand::rngs::StdRng;
@@ -11,17 +13,21 @@ use vortex_alp::ALPArraySlotsExt;
 use vortex_alp::alp_encode;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::dtype::NativePType;
+use vortex_array::session::ArraySession;
 use vortex_error::VortexExpect;
 use vortex_fastlanes::bitpack_compress::bitpack_to_best_bit_width;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
 }
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 fn generate_primitive_array<T: NativePType + NumCast>(
     rng: &mut StdRng,
     len: usize,
@@ -39,7 +45,7 @@ fn generate_bit_pack_primitive_array<T: NativePType + NumCast>(
         .map(|_| T::from_usize(rng.random_range(0..10_000)).vortex_expect(""))
         .collect::<PrimitiveArray>();
 
-    bitpack_to_best_bit_width(&a, &mut LEGACY_SESSION.create_execution_ctx())
+    bitpack_to_best_bit_width(&a, &mut SESSION.create_execution_ctx())
         .vortex_expect("")
         .into_array()
 }
@@ -52,7 +58,7 @@ fn generate_alp_bit_pack_primitive_array<T: NativePType + NumCast>(
         .map(|_| T::from_usize(rng.random_range(0..10_000)).vortex_expect(""))
         .collect::<PrimitiveArray>();
 
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = SESSION.create_execution_ctx();
     let alp = alp_encode(a.as_view(), None, &mut ctx).vortex_expect("");
 
     let encoded = alp
@@ -75,7 +81,6 @@ mod primitive {
     use rand::SeedableRng;
     use rand::prelude::StdRng;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::RecursiveCanonical;
     use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::ConstantArray;
@@ -86,6 +91,7 @@ mod primitive {
     use vortex_error::VortexExpect;
 
     use crate::BENCH_ARGS;
+    use crate::SESSION;
     use crate::generate_primitive_array;
 
     #[divan::bench(
@@ -103,7 +109,7 @@ mod primitive {
         let arr = generate_primitive_array::<T>(&mut rng, len);
 
         bencher
-            .with_inputs(|| (&arr, LEGACY_SESSION.create_execution_ctx()))
+            .with_inputs(|| (&arr, SESSION.create_execution_ctx()))
             .bench_refs(|(arr, ctx)| {
                 arr.clone()
                     .into_array()
@@ -128,7 +134,6 @@ mod bitpack {
     use rand::SeedableRng;
     use rand::prelude::StdRng;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::RecursiveCanonical;
     use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::ConstantArray;
@@ -139,6 +144,7 @@ mod bitpack {
     use vortex_error::VortexExpect;
 
     use crate::BENCH_ARGS;
+    use crate::SESSION;
     use crate::generate_bit_pack_primitive_array;
 
     #[divan::bench(
@@ -156,7 +162,7 @@ mod bitpack {
         let arr = generate_bit_pack_primitive_array::<T>(&mut rng, len);
 
         bencher
-            .with_inputs(|| (&arr, LEGACY_SESSION.create_execution_ctx()))
+            .with_inputs(|| (&arr, SESSION.create_execution_ctx()))
             .bench_refs(|(arr, ctx)| {
                 arr.clone()
                     .between(
@@ -180,7 +186,6 @@ mod alp {
     use rand::SeedableRng;
     use rand::prelude::StdRng;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::RecursiveCanonical;
     use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::ConstantArray;
@@ -191,6 +196,7 @@ mod alp {
     use vortex_error::VortexExpect;
 
     use crate::BENCH_ARGS;
+    use crate::SESSION;
     use crate::generate_alp_bit_pack_primitive_array;
 
     #[divan::bench(
@@ -208,7 +214,7 @@ mod alp {
         let arr = generate_alp_bit_pack_primitive_array::<T>(&mut rng, len);
 
         bencher
-            .with_inputs(|| (&arr, LEGACY_SESSION.create_execution_ctx()))
+            .with_inputs(|| (&arr, SESSION.create_execution_ctx()))
             .bench_refs(|(arr, ctx)| {
                 arr.clone()
                     .between(
diff --git a/encodings/fastlanes/src/bitpacking/array/bitpack_compress.rs b/encodings/fastlanes/src/bitpacking/array/bitpack_compress.rs
index 2e517819059..eba5be1b749 100644
--- a/encodings/fastlanes/src/bitpacking/array/bitpack_compress.rs
+++ b/encodings/fastlanes/src/bitpacking/array/bitpack_compress.rs
@@ -273,15 +273,13 @@ where
     let total_chunks = data.len().div_ceil(1024);
     let mut chunk_offsets: BufferMut<u64> = BufferMut::with_capacity(total_chunks);
 
-    for (idx, value) in data.iter().enumerate() {
+    for ((idx, value), valid) in data.iter().enumerate().zip(validity_mask.iter()) {
         if (idx % 1024) == 0 {
             // Record the patch index offset for each chunk.
             chunk_offsets.push(values.len() as u64);
         }
 
-        if (value.leading_zeros() as usize) < T::PTYPE.bit_width() - bit_width as usize
-            && validity_mask.value(idx)
-        {
+        if (value.leading_zeros() as usize) < T::PTYPE.bit_width() - bit_width as usize && valid {
             indices.push(P::from(idx).vortex_expect("cast index from usize"));
             values.push(*value);
         }
diff --git a/encodings/fastlanes/src/bitpacking/array/bitpack_decompress.rs b/encodings/fastlanes/src/bitpacking/array/bitpack_decompress.rs
index 5b81580d7a6..a4f8224966a 100644
--- a/encodings/fastlanes/src/bitpacking/array/bitpack_decompress.rs
+++ b/encodings/fastlanes/src/bitpacking/array/bitpack_decompress.rs
@@ -113,7 +113,7 @@ where
 
     // SAFETY: We initialize all `len` values below via `decode` and the patch loop.
     unsafe {
-        uninit_range.append_mask(array.validity()?.execute_mask(len, ctx)?);
+        uninit_range.append_mask(&array.validity()?.execute_mask(len, ctx)?);
     }
 
     // SAFETY: `decode` writes a value to every slot in this range.
diff --git a/encodings/fastlanes/src/bitpacking/array/unpack_iter.rs b/encodings/fastlanes/src/bitpacking/array/unpack_iter.rs
index 5e0673186e3..c9158d8bdac 100644
--- a/encodings/fastlanes/src/bitpacking/array/unpack_iter.rs
+++ b/encodings/fastlanes/src/bitpacking/array/unpack_iter.rs
@@ -259,6 +259,34 @@ impl<T: PhysicalPType, S: UnpackStrategy<T>> UnpackedChunks<T, S> {
         debug_assert_eq!(local_idx, self.len);
     }
 
+    /// Walk every *packed* chunk in array order, yielding the raw packed FastLanes block and the
+    /// padded bit range it covers, without unpacking it.
+    ///
+    /// Unlike [`Self::for_each_unpacked_chunk`], this does not fill the scratch buffer: it hands
+    /// the still-packed block to the callback so fused kernels (e.g. compare) can unpack and
+    /// consume it in a single pass. Each yielded block holds exactly `elems_per_chunk` packed
+    /// values (the buffer is zero-padded out to a whole final chunk).
+    ///
+    /// The yielded range is in *padded* coordinates: block `c` covers
+    /// `[c * 1024, min((c + 1) * 1024, offset + len))`, so it includes the leading `offset` rows
+    /// that slicing skips. Block starts are therefore always 1024-aligned regardless of `offset`.
+    /// Callers must account for the array's `offset` when mapping a block's rows back to logical
+    /// output positions (e.g. by viewing the output buffer at a bit offset of `offset`).
+    pub(crate) fn for_each_packed_chunk<F>(&self, mut f: F)
+    where
+        F: FnMut(&[T::Physical], Range<usize>),
+    {
+        let packed_slice: &[T::Physical] = buffer_as_slice(&self.packed);
+        let elems_per_chunk = self.elems_per_chunk();
+        let padded_len = self.offset + self.len;
+        for chunk in 0..self.num_chunks {
+            let packed_chunk = &packed_slice[chunk * elems_per_chunk..][..elems_per_chunk];
+            let start = chunk * CHUNK_SIZE;
+            let end = (start + CHUNK_SIZE).min(padded_len);
+            f(packed_chunk, start..end);
+        }
+    }
+
     /// Unpack full chunks into output range starting at the given index.
     fn decode_full_chunks_into_at(
         &mut self,
diff --git a/encodings/fastlanes/src/bitpacking/compute/between.rs b/encodings/fastlanes/src/bitpacking/compute/between.rs
index 0611d111125..dcc372ad091 100644
--- a/encodings/fastlanes/src/bitpacking/compute/between.rs
+++ b/encodings/fastlanes/src/bitpacking/compute/between.rs
@@ -6,6 +6,8 @@
 //! Reuses the same single-block scratch buffer as the compare kernel and folds a
 //! `lower op_l v op_u upper` predicate per element, so the full primitive never
 //! materialises.
+//!
+//! [`BitPackedArray`]: crate::BitPackedArray
 
 use vortex_array::ArrayRef;
 use vortex_array::ArrayView;
diff --git a/encodings/fastlanes/src/bitpacking/compute/compare.rs b/encodings/fastlanes/src/bitpacking/compute/compare.rs
index f5c5c81c5cb..e622e64a665 100644
--- a/encodings/fastlanes/src/bitpacking/compute/compare.rs
+++ b/encodings/fastlanes/src/bitpacking/compute/compare.rs
@@ -7,12 +7,19 @@
 //! block at a time through a reusable scratch buffer, and a per-element bool is folded into
 //! a [`BitBuffer`]. Patches are re-applied at the end by overwriting bits at the patched
 //! indices with `predicate(patch_value)`.
+//!
+//! [`BitPackedArray`]: crate::BitPackedArray
+//! [`BitBuffer`]: vortex_buffer::BitBuffer
 
+use fastlanes::BitPacking;
+use fastlanes::BitPackingCompare;
+use fastlanes::FastLanesComparable;
 use vortex_array::ArrayRef;
 use vortex_array::ArrayView;
 use vortex_array::ExecutionCtx;
 use vortex_array::dtype::NativePType;
 use vortex_array::dtype::Nullability;
+use vortex_array::dtype::PhysicalPType;
 use vortex_array::match_each_integer_ptype;
 use vortex_array::scalar_fn::fns::binary::CompareKernel;
 use vortex_array::scalar_fn::fns::operators::CompareOperator;
@@ -20,7 +27,8 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
 use crate::BitPacked;
-use crate::bitpacking::compute::stream_predicate::stream_predicate;
+use crate::bitpacking::compute::compare_fused::stream_compare_fused;
+use crate::unpack_iter::BitPacked as BitPackedIter;
 
 impl CompareKernel for BitPacked {
     fn compare(
@@ -55,6 +63,10 @@ impl CompareKernel for BitPacked {
     }
 }
 
+/// Compare every value against the constant via the fused FastLanes `unpack_cmp` kernel.
+///
+/// `NativePType::is_eq` / `is_lt` etc. provide total comparison (matching the primitive between
+/// kernel's dispatch shape). `NotEq` has no direct method, so use `!is_eq`.
 fn compare_constant_typed<T>(
     lhs: ArrayView<'_, BitPacked>,
     rhs: T,
@@ -63,42 +75,60 @@ fn compare_constant_typed<T>(
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef>
 where
-    T: NativePType + Copy + crate::unpack_iter::BitPacked,
+    T: NativePType
+        + BitPackedIter
+        + FastLanesComparable<Bitpacked = <T as PhysicalPType>::Physical>,
+    <T as PhysicalPType>::Physical: BitPacking + NativePType + BitPackingCompare,
 {
-    // `NativePType::is_eq` / `is_lt` etc. provide total comparison (matching the primitive
-    // between kernel's dispatch shape). `NotEq` has no direct method, so use `!is_eq`.
     match operator {
-        CompareOperator::Eq => stream_predicate::<T, _>(lhs, nullability, |v| v.is_eq(rhs), ctx),
+        CompareOperator::Eq => {
+            stream_compare_fused::<T, _>(lhs, rhs, nullability, |a, b| a.is_eq(b), ctx)
+        }
         CompareOperator::NotEq => {
-            stream_predicate::<T, _>(lhs, nullability, |v| !v.is_eq(rhs), ctx)
+            stream_compare_fused::<T, _>(lhs, rhs, nullability, |a, b| !a.is_eq(b), ctx)
+        }
+        CompareOperator::Lt => {
+            stream_compare_fused::<T, _>(lhs, rhs, nullability, |a, b| a.is_lt(b), ctx)
+        }
+        CompareOperator::Lte => {
+            stream_compare_fused::<T, _>(lhs, rhs, nullability, |a, b| a.is_le(b), ctx)
+        }
+        CompareOperator::Gt => {
+            stream_compare_fused::<T, _>(lhs, rhs, nullability, |a, b| a.is_gt(b), ctx)
+        }
+        CompareOperator::Gte => {
+            stream_compare_fused::<T, _>(lhs, rhs, nullability, |a, b| a.is_ge(b), ctx)
         }
-        CompareOperator::Lt => stream_predicate::<T, _>(lhs, nullability, |v| v.is_lt(rhs), ctx),
-        CompareOperator::Lte => stream_predicate::<T, _>(lhs, nullability, |v| v.is_le(rhs), ctx),
-        CompareOperator::Gt => stream_predicate::<T, _>(lhs, nullability, |v| v.is_gt(rhs), ctx),
-        CompareOperator::Gte => stream_predicate::<T, _>(lhs, nullability, |v| v.is_ge(rhs), ctx),
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use std::sync::LazyLock;
+
     use rstest::rstest;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::BoolArray;
     use vortex_array::arrays::ConstantArray;
     use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::arrays::slice::SliceKernel;
     use vortex_array::assert_arrays_eq;
     use vortex_array::builtins::ArrayBuiltins;
     use vortex_array::scalar_fn::fns::binary::CompareKernel;
     use vortex_array::scalar_fn::fns::operators::CompareOperator;
     use vortex_array::scalar_fn::fns::operators::Operator;
+    use vortex_array::session::ArraySession;
     use vortex_error::VortexResult;
+    use vortex_session::VortexSession;
 
     use crate::BitPacked;
     use crate::BitPackedArrayExt;
     use crate::BitPackedData;
 
+    static SESSION: LazyLock<VortexSession> =
+        LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
     /// All six operators on a small in-range input.
     #[rstest]
     #[case(Operator::Eq, vec![false, false, false, true, false, false, true])]
@@ -108,7 +138,7 @@ mod tests {
     #[case(Operator::Gt, vec![false, false, false, false, true, true, false])]
     #[case(Operator::Gte, vec![false, false, false, true, true, true, true])]
     fn small(#[case] op: Operator, #[case] expected: Vec<bool>) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let values = PrimitiveArray::from_iter([0u32, 1, 2, 3, 4, 5, 3]);
         let packed = BitPackedData::encode(&values.into_array(), 3, &mut ctx).unwrap();
         let rhs = ConstantArray::new(3u32, packed.len()).into_array();
@@ -130,7 +160,7 @@ mod tests {
         ($name:ident, $T:ty, $($bw:expr),+) => {
             #[test]
             fn $name() -> VortexResult<()> {
-                let mut ctx = LEGACY_SESSION.create_execution_ctx();
+                let mut ctx = SESSION.create_execution_ctx();
                 for bw in [$($bw),+] {
                     let cap: u128 = 1u128 << bw;
                     let values: Vec<$T> = (0..2048u128).map(|i| (i % cap) as $T).collect();
@@ -171,7 +201,7 @@ mod tests {
     /// predicate runs.
     #[test]
     fn signed_with_patches_matches_primitive() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let values: Vec<i32> = (0..1500)
             .map(|i| if i % 73 == 0 { 100_000 + i } else { i % 100 })
             .collect();
@@ -191,10 +221,91 @@ mod tests {
         Ok(())
     }
 
+    /// Sliced inputs: a non-zero block offset (and a length spanning several blocks) must still go
+    /// through the fused kernel and agree with the primitive fallback. Sweeps slice starts that
+    /// land both inside the first block and past it, with lengths that end mid-block and on a block
+    /// boundary.
+    #[rstest]
+    #[case(1, 4000)] // start mid-first-block, multi-block length
+    #[case(1023, 2)] // start at the last row of the first block
+    #[case(1024, 1024)] // start exactly on a block boundary, exactly one block long
+    #[case(1500, 1000)] // start mid-second-block
+    #[case(3, 1021)] // ends exactly on the first block boundary
+    fn sliced_matches_primitive(
+        #[case] start: usize,
+        #[case] slice_len: usize,
+    ) -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
+        let values: Vec<u32> = (0..5000u32).map(|i| i % 128).collect();
+        let prim = PrimitiveArray::from_iter(values);
+        let packed = BitPackedData::encode(&prim.clone().into_array(), 7, &mut ctx)?;
+
+        let sliced = packed.into_array().slice(start..start + slice_len)?;
+        let rhs = ConstantArray::new(50u32, slice_len).into_array();
+        for op in [
+            CompareOperator::Eq,
+            CompareOperator::Lt,
+            CompareOperator::Gte,
+        ] {
+            let got = <BitPacked as CompareKernel>::compare(
+                sliced.as_::<BitPacked>(),
+                &rhs,
+                op,
+                &mut ctx,
+            )?
+            .expect("fused compare kernel must engage for sliced arrays")
+            .execute::<BoolArray>(&mut ctx)?;
+            let want = prim
+                .clone()
+                .into_array()
+                .slice(start..start + slice_len)?
+                .binary(rhs.clone(), Operator::from(op))?
+                .execute::<BoolArray>(&mut ctx)?;
+            assert_arrays_eq!(got, want);
+        }
+        Ok(())
+    }
+
+    /// Sliced *and* patched: combine a non-zero offset with out-of-range values that land in
+    /// `Patches`, exercising the `offset + (global - p_off)` patch-position math.
+    #[test]
+    fn sliced_with_patches_matches_primitive() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
+        let values: Vec<i32> = (0..4096)
+            .map(|i| if i % 91 == 0 { 100_000 + i } else { i % 100 })
+            .collect();
+        let prim = PrimitiveArray::from_iter(values);
+        let packed = BitPackedData::encode(&prim.clone().into_array(), 7, &mut ctx)?;
+        assert!(packed.patches().is_some(), "test setup expects patches");
+
+        let (start, end) = (700usize, 3500usize);
+        // `ArrayRef::slice` leaves a lazy `SliceArray` over a patched `BitPacked` (the
+        // `SliceReduce` path bails when patches are present), so go through the `SliceKernel`,
+        // which reads the buffers and produces a sliced `BitPacked` with sliced patches.
+        let sliced = <BitPacked as SliceKernel>::slice(packed.as_view(), start..end, &mut ctx)?
+            .expect("slice kernel produces a sliced bitpacked array");
+        let rhs = ConstantArray::new(50i32, end - start).into_array();
+        let got = <BitPacked as CompareKernel>::compare(
+            sliced.as_::<BitPacked>(),
+            &rhs,
+            CompareOperator::Eq,
+            &mut ctx,
+        )?
+        .expect("fused compare kernel must engage for sliced arrays with patches")
+        .execute::<BoolArray>(&mut ctx)?;
+        let want = prim
+            .into_array()
+            .slice(start..end)?
+            .binary(rhs, Operator::Eq)?
+            .execute::<BoolArray>(&mut ctx)?;
+        assert_arrays_eq!(got, want);
+        Ok(())
+    }
+
     /// Nullable input — the result must carry the array's validity.
     #[test]
     fn nullable_propagates_validity() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let prim = PrimitiveArray::from_option_iter([Some(1u32), None, Some(3), Some(4), None]);
         let packed = BitPackedData::encode(&prim.clone().into_array(), 3, &mut ctx)?;
         let rhs = ConstantArray::new(3u32, packed.len()).into_array();
diff --git a/encodings/fastlanes/src/bitpacking/compute/compare_fused.rs b/encodings/fastlanes/src/bitpacking/compute/compare_fused.rs
new file mode 100644
index 00000000000..baf3b0ede96
--- /dev/null
+++ b/encodings/fastlanes/src/bitpacking/compute/compare_fused.rs
@@ -0,0 +1,143 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Fused compare kernel for [`BitPackedArray`] against a constant.
+//!
+//! Where [`super::stream_predicate`] unpacks a full 1024-element FastLanes block into a scratch
+//! buffer and *then* folds a predicate over it, this path hands the comparison down into the
+//! FastLanes [`BitPackingCompare::unchecked_unpack_cmp`] kernel, which compares each value against
+//! the constant *as it is unpacked*, accumulating the boolean results straight into a 1024-bit
+//! mask (`[u64; 16]`) in transposed FastLanes lane order - one register-resident word per lane, no
+//! `[bool; 1024]` or `[T; 1024]` scratch. A single SIMD [`untranspose_bits`] per block then rotates
+//! that mask into logical row order.
+//!
+//! The packed blocks are walked through the regular [`crate::unpack_iter::BitUnpackedChunks`]
+//! iterator (via [`crate::unpack_iter::BitUnpackedChunks::for_each_packed_chunk`]) rather than a
+//! bespoke chunk loop, so chunk sizing and bounds live in one place.
+//!
+//! Slicing is handled by working in *padded* coordinates: bit `offset + i` holds element `i`. The
+//! output buffer is over-allocated to whole 1024-bit blocks, so every block - the sliced first
+//! block, the body, and the trailing partial - untransposes straight into a 64-bit-word-aligned
+//! slot with no per-block temporary and only one shared scratch `[u64; 16]`. The leading `offset`
+//! garbage rows are represented as the final [`BitBuffer`] bit offset, which naturally handles
+//! sub-byte slices without copy-aligning. Inline patches are spliced in afterwards by overwriting
+//! the bits at the patched indices with `cmp(patch_value, rhs)`.
+//!
+//! [`BitPackedArray`]: crate::BitPackedArray
+//! [`BitBuffer`]: vortex_buffer::BitBuffer
+
+use fastlanes::BitPacking;
+use fastlanes::BitPackingCompare;
+use fastlanes::FastLanesComparable;
+use fastlanes::untranspose_bits;
+use num_traits::AsPrimitive;
+use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
+use vortex_array::arrays::BoolArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::dtype::NativePType;
+use vortex_array::dtype::Nullability;
+use vortex_array::dtype::PhysicalPType;
+use vortex_array::match_each_unsigned_integer_ptype;
+use vortex_buffer::BitBufferMut;
+use vortex_buffer::BufferMut;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+
+use super::stream_predicate::stream_predicate;
+use crate::BitPacked;
+use crate::BitPackedArrayExt;
+use crate::unpack_iter::BitPacked as BitPackedIter;
+
+const CHUNK_SIZE: usize = 1024;
+const U64_BITS: usize = u64::BITS as usize;
+/// `u64` words spanning one FastLanes block (1024 bits / 64).
+const WORDS_PER_CHUNK: usize = CHUNK_SIZE / U64_BITS;
+
+/// Compare the unpacked values of a [`BitPackedArray`] against `rhs` using the fused FastLanes
+/// `unpack_cmp` kernel, producing a [`BoolArray`].
+///
+/// `cmp(value, rhs)` defines the predicate; it must be the total-order comparison matching the
+/// requested operator (e.g. `|a, b| a.is_lt(b)`).
+///
+/// [`BitPackedArray`]: crate::BitPackedArray
+pub(super) fn stream_compare_fused<T, F>(
+    array: ArrayView<'_, BitPacked>,
+    rhs: T,
+    nullability: Nullability,
+    cmp: F,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ArrayRef>
+where
+    T: NativePType
+        + BitPackedIter
+        + FastLanesComparable<Bitpacked = <T as PhysicalPType>::Physical>,
+    <T as PhysicalPType>::Physical: BitPacking + NativePType + BitPackingCompare,
+    F: Fn(T, T) -> bool + Copy,
+{
+    let len = array.len();
+    let bit_width = array.bit_width() as usize;
+    let offset = array.offset() as usize;
+
+    // A degenerate width has no packed payload for the fused kernel to consume; defer to the scalar
+    // streaming predicate, which handles every layout (including the empty array).
+    if len == 0 || bit_width == 0 {
+        return stream_predicate::<T, _>(array, nullability, move |v| cmp(v, rhs), ctx);
+    }
+
+    // Over-allocate to whole 1024-bit blocks in padded coordinates so every block - including the
+    // trailing partial - has room for a full untranspose at a 64-bit-word-aligned offset.
+    let num_chunks = (offset + len).div_ceil(CHUNK_SIZE);
+    let mut words: BufferMut<u64> = BufferMut::zeroed(num_chunks * WORDS_PER_CHUNK);
+
+    let chunks = array.unpacked_chunks::<T>()?;
+    {
+        let words = words.as_mut_slice();
+        let mut transposed = [0u64; WORDS_PER_CHUNK];
+        chunks.for_each_packed_chunk(|packed_chunk, range| {
+            // Block starts are always 1024-aligned (padded coords), so the slot is a full block.
+            let out = words[range.start / U64_BITS..]
+                .first_chunk_mut::<WORDS_PER_CHUNK>()
+                .vortex_expect("over-allocated buffer holds a full block per chunk");
+            // SAFETY: `packed_chunk` holds exactly `128 * bit_width / size_of::<U>()` packed
+            // elements and `bit_width <= U::T`, satisfying `unchecked_unpack_cmp`'s contract. The
+            // kernel assigns every word in `transposed`, so its previous contents are irrelevant.
+            unsafe {
+                <<T as PhysicalPType>::Physical as BitPackingCompare>::unchecked_unpack_cmp::<T, _>(
+                    bit_width,
+                    packed_chunk,
+                    &mut transposed,
+                    cmp,
+                    rhs,
+                );
+            }
+            untranspose_bits::<<T as PhysicalPType>::Physical>(&transposed, out);
+        });
+    }
+
+    let mut bits = BitBufferMut::from_buffer(words.into_byte_buffer(), offset, len);
+
+    // Patched indices hold placeholder packed values, so their fused result is meaningless;
+    // overwrite each with the comparison against the real patch value.
+    // TODO(joe): apply patches per `packed_chunked`.
+    if let Some(p) = array.patches() {
+        let p_idx = p.indices().clone().execute::<PrimitiveArray>(ctx)?;
+        // TODO(joe): push down cmp??
+        let p_val = p.values().clone().execute::<PrimitiveArray>(ctx)?;
+        let p_off = p.offset();
+        match_each_unsigned_integer_ptype!(p_idx.ptype(), |I| {
+            let indices = p_idx.as_slice::<I>();
+            let values = p_val.as_slice::<T>();
+            for (&global, &value) in indices.iter().zip(values) {
+                let global: usize = global.as_();
+                let idx = global - p_off;
+                bits.set_to(idx, cmp(value, rhs))
+            }
+        });
+    }
+
+    let validity = array.validity()?.union_nullability(nullability);
+    Ok(BoolArray::new(bits.freeze(), validity).into_array())
+}
diff --git a/encodings/fastlanes/src/bitpacking/compute/filter.rs b/encodings/fastlanes/src/bitpacking/compute/filter.rs
index 06e50e09bf0..284ae5bce4c 100644
--- a/encodings/fastlanes/src/bitpacking/compute/filter.rs
+++ b/encodings/fastlanes/src/bitpacking/compute/filter.rs
@@ -28,7 +28,7 @@ use crate::BitPacked;
 use crate::BitPackedArrayExt;
 use crate::BitPackedData;
 
-/// The threshold over which it is faster to fully unpack the entire [`BitPackedArray`] and then
+/// The threshold over which it is faster to fully unpack the entire [`BitPackedArray`](crate::BitPackedArray) and then
 /// filter the result than to unpack only specific bitpacked values into the output buffer.
 pub const fn unpack_then_filter_threshold(ptype: PType) -> f64 {
     // TODO(connor): Where did these numbers come from? Add a public link after validating them.
diff --git a/encodings/fastlanes/src/bitpacking/compute/mod.rs b/encodings/fastlanes/src/bitpacking/compute/mod.rs
index 518f8319eb1..06a4b4597b0 100644
--- a/encodings/fastlanes/src/bitpacking/compute/mod.rs
+++ b/encodings/fastlanes/src/bitpacking/compute/mod.rs
@@ -4,6 +4,7 @@
 mod between;
 mod cast;
 mod compare;
+mod compare_fused;
 mod filter;
 pub(crate) mod is_constant;
 mod slice;
diff --git a/encodings/fastlanes/src/bitpacking/compute/stream_predicate.rs b/encodings/fastlanes/src/bitpacking/compute/stream_predicate.rs
index 4ed9de913ec..a85cc358c60 100644
--- a/encodings/fastlanes/src/bitpacking/compute/stream_predicate.rs
+++ b/encodings/fastlanes/src/bitpacking/compute/stream_predicate.rs
@@ -4,12 +4,16 @@
 //! Streaming, cache-reusable predicate evaluation over a [`BitPackedArray`].
 //!
 //! Walks the encoded array one 1024-element FastLanes block at a time through a single
-//! reusable scratch buffer, splices any [`crate::patches::Patches`] into the unpacked block
+//! reusable scratch buffer, splices any [`Patches`] into the unpacked block
 //! in place via a sorted-index cursor, then folds a `Fn(T) -> bool` predicate over the
-//! block. The fold matches the canonical [`vortex_buffer::BitBuffer::collect_bool`] shape
+//! block. The fold matches the canonical [`BitBuffer::collect_bool`] shape
 //! (pack 64 bools into a `u64` in a tight auto-vectorisable inner loop) and writes the
 //! resulting words straight into the output bit buffer, so the materialised primitive
 //! never appears anywhere.
+//!
+//! [`BitPackedArray`]: crate::BitPackedArray
+//! [`BitBuffer::collect_bool`]: vortex_buffer::BitBuffer::collect_bool
+//! [`Patches`]: vortex_array::patches::Patches
 
 use num_traits::AsPrimitive;
 use vortex_array::ArrayRef;
@@ -30,7 +34,7 @@ use crate::BitPacked;
 use crate::BitPackedArrayExt;
 use crate::unpack_iter::BitPacked as BitPackedIter;
 
-/// Stream `predicate` over the unpacked values of a [`BitPackedArray`], one FastLanes
+/// Stream `predicate` over the unpacked values of a [`BitPackedArray`](crate::BitPackedArray), one FastLanes
 /// block at a time, producing a [`BoolArray`].
 pub(super) fn stream_predicate<T, P>(
     array: ArrayView<'_, BitPacked>,
diff --git a/encodings/fastlanes/src/bitpacking/compute/take.rs b/encodings/fastlanes/src/bitpacking/compute/take.rs
index a4c148c5717..bbf5bfaf2c8 100644
--- a/encodings/fastlanes/src/bitpacking/compute/take.rs
+++ b/encodings/fastlanes/src/bitpacking/compute/take.rs
@@ -30,7 +30,7 @@ use crate::bitpack_decompress;
 // TODO(connor): This is duplicated in `encodings/fastlanes/src/bitpacking/kernels/mod.rs`.
 /// assuming the buffer is already allocated (which will happen at most once) then unpacking
 /// all 1024 elements takes ~8.8x as long as unpacking a single element on an M2 Macbook Air.
-/// see https://github.com/vortex-data/vortex/pull/190#issue-2223752833
+/// see <https://github.com/vortex-data/vortex/pull/190#issue-2223752833>
 pub(super) const UNPACK_CHUNK_THRESHOLD: usize = 8;
 
 impl TakeExecute for BitPacked {
diff --git a/encodings/fastlanes/src/bitpacking/vtable/mod.rs b/encodings/fastlanes/src/bitpacking/vtable/mod.rs
index 912dd4ff44b..52b536e02c5 100644
--- a/encodings/fastlanes/src/bitpacking/vtable/mod.rs
+++ b/encodings/fastlanes/src/bitpacking/vtable/mod.rs
@@ -13,10 +13,10 @@ use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
 use vortex_array::ArraySlots;
 use vortex_array::ArrayView;
+use vortex_array::EqMode;
 use vortex_array::ExecutionCtx;
 use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
-use vortex_array::Precision;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::builders::ArrayBuilder;
 use vortex_array::dtype::DType;
@@ -69,19 +69,19 @@ pub struct BitPackedMetadata {
 }
 
 impl ArrayHash for BitPackedData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, accuracy: EqMode) {
         self.offset.hash(state);
         self.bit_width.hash(state);
-        self.packed.array_hash(state, precision);
+        self.packed.array_hash(state, accuracy);
         self.patches_data.hash(state);
     }
 }
 
 impl ArrayEq for BitPackedData {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, accuracy: EqMode) -> bool {
         self.offset == other.offset
             && self.bit_width == other.bit_width
-            && self.packed.array_eq(&other.packed, precision)
+            && self.packed.array_eq(&other.packed, accuracy)
             && self.patches_data == other.patches_data
     }
 }
diff --git a/encodings/fastlanes/src/delta/vtable/mod.rs b/encodings/fastlanes/src/delta/vtable/mod.rs
index b5e68791ceb..dfb440620ab 100644
--- a/encodings/fastlanes/src/delta/vtable/mod.rs
+++ b/encodings/fastlanes/src/delta/vtable/mod.rs
@@ -12,10 +12,10 @@ use vortex_array::ArrayId;
 use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
 use vortex_array::ArrayView;
+use vortex_array::EqMode;
 use vortex_array::ExecutionCtx;
 use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
-use vortex_array::Precision;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::DType;
@@ -58,13 +58,13 @@ pub struct DeltaMetadata {
 }
 
 impl ArrayHash for DeltaData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _accuracy: EqMode) {
         self.offset.hash(state);
     }
 }
 
 impl ArrayEq for DeltaData {
-    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, _accuracy: EqMode) -> bool {
         self.offset == other.offset
     }
 }
diff --git a/encodings/fastlanes/src/for/array/for_decompress.rs b/encodings/fastlanes/src/for/array/for_decompress.rs
index 073864411fb..ffe9449f962 100644
--- a/encodings/fastlanes/src/for/array/for_decompress.rs
+++ b/encodings/fastlanes/src/for/array/for_decompress.rs
@@ -109,7 +109,7 @@ pub(crate) fn fused_decompress<
     let mut uninit_range = builder.uninit_range(bp.len());
     unsafe {
         // Append a dense null Mask.
-        uninit_range.append_mask(bp.validity()?.execute_mask(bp.as_ref().len(), ctx)?);
+        uninit_range.append_mask(&bp.validity()?.execute_mask(bp.as_ref().len(), ctx)?);
     }
 
     // SAFETY: `decode_into` will initialize all values in this range.
diff --git a/encodings/fastlanes/src/for/vtable/mod.rs b/encodings/fastlanes/src/for/vtable/mod.rs
index 899276341de..037a858892e 100644
--- a/encodings/fastlanes/src/for/vtable/mod.rs
+++ b/encodings/fastlanes/src/for/vtable/mod.rs
@@ -12,10 +12,10 @@ use vortex_array::ArrayId;
 use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
 use vortex_array::ArrayView;
+use vortex_array::EqMode;
 use vortex_array::ExecutionCtx;
 use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
-use vortex_array::Precision;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::DType;
@@ -50,13 +50,13 @@ mod validity;
 pub type FoRArray = Array<FoR>;
 
 impl ArrayHash for FoRData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _accuracy: EqMode) {
         self.reference.hash(state);
     }
 }
 
 impl ArrayEq for FoRData {
-    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, _accuracy: EqMode) -> bool {
         self.reference == other.reference
     }
 }
diff --git a/encodings/fastlanes/src/rle/array/rle_compress.rs b/encodings/fastlanes/src/rle/array/rle_compress.rs
index e48f31f51da..107c912c23f 100644
--- a/encodings/fastlanes/src/rle/array/rle_compress.rs
+++ b/encodings/fastlanes/src/rle/array/rle_compress.rs
@@ -440,7 +440,7 @@ mod tests {
         let mut rng_state: u32 = 0xDEAD_BEEF;
         let validity = indices_prim.validity()?;
         for (i, idx) in indices_data.iter_mut().enumerate() {
-            if !validity.is_valid(i).unwrap_or(true) {
+            if !validity.execute_is_valid(i, ctx).unwrap_or(true) {
                 // xorshift32
                 rng_state ^= rng_state << 13;
                 rng_state ^= rng_state >> 17;
diff --git a/encodings/fastlanes/src/rle/vtable/mod.rs b/encodings/fastlanes/src/rle/vtable/mod.rs
index 989b462ab99..82c236ae810 100644
--- a/encodings/fastlanes/src/rle/vtable/mod.rs
+++ b/encodings/fastlanes/src/rle/vtable/mod.rs
@@ -12,10 +12,10 @@ use vortex_array::ArrayId;
 use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
 use vortex_array::ArrayView;
+use vortex_array::EqMode;
 use vortex_array::ExecutionCtx;
 use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
-use vortex_array::Precision;
 use vortex_array::arrays::Primitive;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::DType;
@@ -65,13 +65,13 @@ pub struct RLEMetadata {
 }
 
 impl ArrayHash for RLEData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _accuracy: EqMode) {
         self.offset.hash(state);
     }
 }
 
 impl ArrayEq for RLEData {
-    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, _accuracy: EqMode) -> bool {
         self.offset == other.offset
     }
 }
diff --git a/encodings/fsst/benches/fsst_compress.rs b/encodings/fsst/benches/fsst_compress.rs
index 45aedfa464f..88e4e26a903 100644
--- a/encodings/fsst/benches/fsst_compress.rs
+++ b/encodings/fsst/benches/fsst_compress.rs
@@ -11,7 +11,6 @@ use rand::SeedableRng;
 use rand::rngs::StdRng;
 use vortex_array::Canonical;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::RecursiveCanonical;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::ChunkedArray;
@@ -57,7 +56,7 @@ fn compress_fsst(bencher: Bencher, (string_count, avg_len, unique_chars): (usize
     let array = generate_test_data(string_count, avg_len, unique_chars);
     let compressor = fsst_train_compressor(&array);
     bencher
-        .with_inputs(|| (&array, &compressor, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&array, &compressor, SESSION.create_execution_ctx()))
         .bench_refs(|(array, compressor, ctx)| {
             fsst_compress(*array, array.len(), array.dtype(), compressor, ctx)
         })
@@ -74,11 +73,11 @@ fn decompress_fsst(bencher: Bencher, (string_count, avg_len, unique_chars): (usi
         len,
         &dtype,
         &compressor,
-        &mut LEGACY_SESSION.create_execution_ctx(),
+        &mut SESSION.create_execution_ctx(),
     );
 
     bencher
-        .with_inputs(|| (&encoded, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&encoded, SESSION.create_execution_ctx()))
         .bench_refs(|(encoded, ctx)| (**encoded).clone().into_array().execute::<Canonical>(ctx))
 }
 
@@ -99,18 +98,12 @@ fn pushdown_compare(bencher: Bencher, (string_count, avg_len, unique_chars): (us
         array.len(),
         array.dtype(),
         &compressor,
-        &mut LEGACY_SESSION.create_execution_ctx(),
+        &mut SESSION.create_execution_ctx(),
     );
     let constant = ConstantArray::new(Scalar::from(&b"const"[..]), array.len());
 
     bencher
-        .with_inputs(|| {
-            (
-                &fsst_array,
-                &constant,
-                LEGACY_SESSION.create_execution_ctx(),
-            )
-        })
+        .with_inputs(|| (&fsst_array, &constant, SESSION.create_execution_ctx()))
         .bench_refs(|(fsst_array, constant, ctx)| {
             fsst_array
                 .clone()
@@ -134,18 +127,12 @@ fn canonicalize_compare(
         array.len(),
         array.dtype(),
         &compressor,
-        &mut LEGACY_SESSION.create_execution_ctx(),
+        &mut SESSION.create_execution_ctx(),
     );
     let constant = ConstantArray::new(Scalar::from(&b"const"[..]), array.len());
 
     bencher
-        .with_inputs(|| {
-            (
-                &fsst_array,
-                &constant,
-                LEGACY_SESSION.create_execution_ctx(),
-            )
-        })
+        .with_inputs(|| (&fsst_array, &constant, SESSION.create_execution_ctx()))
         .bench_refs(|(fsst_array, constant, ctx)| {
             (*fsst_array)
                 .clone()
@@ -235,7 +222,7 @@ fn generate_chunked_test_data(
     avg_len: usize,
     unique_chars: u8,
 ) -> ChunkedArray {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = SESSION.create_execution_ctx();
     (0..chunk_size)
         .map(|_| {
             let array = generate_test_data(string_count, avg_len, unique_chars);
diff --git a/encodings/fsst/src/array.rs b/encodings/fsst/src/array.rs
index 617908e94dd..83360a69e64 100644
--- a/encodings/fsst/src/array.rs
+++ b/encodings/fsst/src/array.rs
@@ -6,7 +6,7 @@ use std::fmt::Display;
 use std::fmt::Formatter;
 use std::hash::Hasher;
 use std::sync::Arc;
-use std::sync::LazyLock;
+use std::sync::OnceLock;
 
 use fsst::Compressor;
 use fsst::Decompressor;
@@ -21,11 +21,11 @@ use vortex_array::ArrayRef;
 use vortex_array::ArraySlots;
 use vortex_array::ArrayView;
 use vortex_array::Canonical;
+use vortex_array::EqMode;
 use vortex_array::ExecutionCtx;
 use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::LEGACY_SESSION;
-use vortex_array::Precision;
 use vortex_array::TypedArrayRef;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::VarBin;
@@ -80,19 +80,24 @@ impl FSSTMetadata {
 }
 
 impl ArrayHash for FSSTData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
-        self.symbols.array_hash(state, precision);
-        self.symbol_lengths.array_hash(state, precision);
+    fn array_hash<H: Hasher>(&self, state: &mut H, precision: EqMode) {
+        self.symbol_table.symbols.array_hash(state, precision);
+        self.symbol_table
+            .symbol_lengths
+            .array_hash(state, precision);
         self.codes_bytes.as_host().array_hash(state, precision);
     }
 }
 
 impl ArrayEq for FSSTData {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
-        self.symbols.array_eq(&other.symbols, precision)
+    fn array_eq(&self, other: &Self, precision: EqMode) -> bool {
+        self.symbol_table
+            .symbols
+            .array_eq(&other.symbol_table.symbols, precision)
             && self
+                .symbol_table
                 .symbol_lengths
-                .array_eq(&other.symbol_lengths, precision)
+                .array_eq(&other.symbol_table.symbol_lengths, precision)
             && self
                 .codes_bytes
                 .as_host()
@@ -346,28 +351,29 @@ pub(crate) const SLOT_NAMES: [&str; NUM_SLOTS] =
 /// [`FSSTArrayExt::codes()`], combining this buffer with the offsets/validity from slots.
 #[derive(Clone)]
 pub struct FSSTData {
-    symbols: Buffer<Symbol>,
-    symbol_lengths: Buffer<u8>,
+    symbol_table: Arc<FSSTSymbolTable>,
     /// The raw compressed codes bytes, equivalent to `VarBinData::bytes`.
     codes_bytes: BufferHandle,
     /// Cached length (number of elements).
     len: usize,
-
-    /// Memoized compressor used for push-down of compute by compressing the RHS.
-    compressor: Arc<LazyLock<Compressor, Box<dyn Fn() -> Compressor + Send>>>,
 }
 
 impl Display for FSSTData {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "len: {}, nsymbols: {}", self.len, self.symbols.len())
+        write!(
+            f,
+            "len: {}, nsymbols: {}",
+            self.len,
+            self.symbol_table.symbols.len()
+        )
     }
 }
 
 impl Debug for FSSTData {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("FSSTArray")
-            .field("symbols", &self.symbols)
-            .field("symbol_lengths", &self.symbol_lengths)
+            .field("symbols", &self.symbol_table.symbols)
+            .field("symbol_lengths", &self.symbol_table.symbol_lengths)
             .field("codes_bytes_len", &self.codes_bytes.len())
             .field("len", &self.len)
             .field("uncompressed_lengths", &"<outer slot>")
@@ -377,6 +383,29 @@ impl Debug for FSSTData {
     }
 }
 
+pub(crate) struct FSSTSymbolTable {
+    symbols: Buffer<Symbol>,
+    symbol_lengths: Buffer<u8>,
+    /// Memoized compressor used for push-down of compute by compressing the RHS.
+    compressor: OnceLock<Compressor>,
+}
+
+impl FSSTSymbolTable {
+    fn new(symbols: Buffer<Symbol>, symbol_lengths: Buffer<u8>) -> Self {
+        Self {
+            symbols,
+            symbol_lengths,
+            compressor: OnceLock::new(),
+        }
+    }
+
+    fn compressor(&self) -> &Compressor {
+        self.compressor.get_or_init(|| {
+            Compressor::rebuild_from(self.symbols.as_slice(), self.symbol_lengths.as_slice())
+        })
+    }
+}
+
 #[derive(Clone, Debug)]
 pub struct FSST;
 
@@ -412,6 +441,32 @@ impl FSST {
         })
     }
 
+    pub(crate) fn try_new_with_symbol_table(
+        dtype: DType,
+        symbol_table: Arc<FSSTSymbolTable>,
+        codes: VarBinArray,
+        uncompressed_lengths: ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<FSSTArray> {
+        let len = codes.len();
+        FSSTData::validate_parts_from_codes(
+            &symbol_table.symbols,
+            &symbol_table.symbol_lengths,
+            &codes,
+            &uncompressed_lengths,
+            &dtype,
+            len,
+            ctx,
+        )?;
+        let slots = FSSTData::make_slots(&codes, &uncompressed_lengths);
+        let codes_bytes = codes.bytes_handle().clone();
+        let data =
+            unsafe { FSSTData::new_unchecked_with_symbol_table(symbol_table, codes_bytes, len) };
+        Ok(unsafe {
+            Array::from_parts_unchecked(ArrayParts::new(FSST, dtype, len, data).with_slots(slots))
+        })
+    }
+
     /// Legacy deserialization path (2 buffers): the codes were stored as a full
     /// `VarBinArray` child. We decompose the VarBinArray into its bytes (stored in
     /// FSSTData) and offsets/validity (stored in slots).
@@ -463,17 +518,17 @@ impl FSST {
         Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
-    pub(crate) unsafe fn new_unchecked(
+    pub(crate) unsafe fn new_unchecked_with_symbol_table(
         dtype: DType,
-        symbols: Buffer<Symbol>,
-        symbol_lengths: Buffer<u8>,
+        symbol_table: Arc<FSSTSymbolTable>,
         codes: VarBinArray,
         uncompressed_lengths: ArrayRef,
     ) -> FSSTArray {
         let len = codes.len();
         let slots = FSSTData::make_slots(&codes, &uncompressed_lengths);
         let codes_bytes = codes.bytes_handle().clone();
-        let data = unsafe { FSSTData::new_unchecked(symbols, symbol_lengths, codes_bytes, len) };
+        let data =
+            unsafe { FSSTData::new_unchecked_with_symbol_table(symbol_table, codes_bytes, len) };
         unsafe {
             Array::from_parts_unchecked(ArrayParts::new(FSST, dtype, len, data).with_slots(slots))
         }
@@ -534,8 +589,8 @@ impl FSSTData {
             .as_ref()
             .vortex_expect("FSSTArray codes_offsets slot");
         Self::validate_parts(
-            &self.symbols,
-            &self.symbol_lengths,
+            &self.symbol_table.symbols,
+            &self.symbol_table.symbol_lengths,
             &self.codes_bytes,
             codes_offsets,
             dtype.nullability(),
@@ -567,10 +622,13 @@ impl FSSTData {
         if symbols.len() > 255 {
             vortex_bail!(InvalidArgument: "symbols array must have length <= 255");
         }
+
         if symbols.len() != symbol_lengths.len() {
             vortex_bail!(InvalidArgument: "symbols and symbol_lengths arrays must have same length");
         }
 
+        Self::validate_symbol_lengths(symbol_lengths.as_slice())?;
+
         // codes_offsets.len() - 1 == number of elements
         let codes_len = codes_offsets.len().saturating_sub(1);
         if codes_len != len {
@@ -612,6 +670,32 @@ impl FSSTData {
         Ok(())
     }
 
+    fn validate_symbol_lengths(symbol_lengths: &[u8]) -> VortexResult<()> {
+        let mut expected = 2;
+        for (idx, &len) in symbol_lengths.iter().enumerate() {
+            if len > 8 || len == 0 {
+                vortex_bail!(InvalidArgument: "symbol length at index {idx} must be between 1 and 8, found {len}");
+            }
+
+            if expected == 1 {
+                if len != 1 {
+                    vortex_bail!(InvalidArgument: "symbol length at index {idx} must be 1 after one-byte symbols begin, found {len}");
+                }
+            } else {
+                if len == 1 {
+                    expected = 1;
+                }
+
+                if len < expected {
+                    vortex_bail!(InvalidArgument: "symbol length at index {idx} violates FSST symbol table ordering");
+                }
+                expected = len;
+            }
+        }
+
+        Ok(())
+    }
+
     /// Validate using a VarBinArray for the codes (convenience for construction paths).
     fn validate_parts_from_codes(
         symbols: &Buffer<Symbol>,
@@ -641,18 +725,19 @@ impl FSSTData {
         codes_bytes: BufferHandle,
         len: usize,
     ) -> Self {
-        let symbols2 = symbols.clone();
-        let symbol_lengths2 = symbol_lengths.clone();
-        let compressor = Arc::new(LazyLock::new(Box::new(move || {
-            Compressor::rebuild_from(symbols2.as_slice(), symbol_lengths2.as_slice())
-        })
-            as Box<dyn Fn() -> Compressor + Send>));
+        let symbol_table = Arc::new(FSSTSymbolTable::new(symbols, symbol_lengths));
+        unsafe { Self::new_unchecked_with_symbol_table(symbol_table, codes_bytes, len) }
+    }
+
+    pub(crate) unsafe fn new_unchecked_with_symbol_table(
+        symbol_table: Arc<FSSTSymbolTable>,
+        codes_bytes: BufferHandle,
+        len: usize,
+    ) -> Self {
         Self {
-            symbols,
-            symbol_lengths,
+            symbol_table,
             codes_bytes,
             len,
-            compressor,
         }
     }
 
@@ -668,12 +753,16 @@ impl FSSTData {
 
     /// Access the symbol table array.
     pub fn symbols(&self) -> &Buffer<Symbol> {
-        &self.symbols
+        &self.symbol_table.symbols
     }
 
     /// Access the symbol lengths array.
     pub fn symbol_lengths(&self) -> &Buffer<u8> {
-        &self.symbol_lengths
+        &self.symbol_table.symbol_lengths
+    }
+
+    pub(crate) fn symbol_table(&self) -> Arc<FSSTSymbolTable> {
+        Arc::clone(&self.symbol_table)
     }
 
     /// Access the compressed codes bytes buffer handle (may be on host or device).
@@ -686,7 +775,7 @@ impl FSSTData {
         self.codes_bytes.as_host()
     }
 
-    /// Build a [`Decompressor`][fsst::Decompressor] that can be used to decompress values from
+    /// Build a [`Decompressor`] that can be used to decompress values from
     /// this array.
     pub fn decompressor(&self) -> Decompressor<'_> {
         Decompressor::new(self.symbols().as_slice(), self.symbol_lengths().as_slice())
@@ -694,7 +783,7 @@ impl FSSTData {
 
     /// Retrieves the FSST compressor.
     pub fn compressor(&self) -> &Compressor {
-        self.compressor.as_ref()
+        self.symbol_table.compressor()
     }
 }
 
@@ -771,12 +860,48 @@ mod test {
     use vortex_array::test_harness::check_metadata;
     use vortex_buffer::Buffer;
     use vortex_error::VortexError;
+    use vortex_error::VortexResult;
+    use vortex_error::vortex_err;
 
     use crate::FSST;
     use crate::array::FSSTArrayExt;
     use crate::array::FSSTMetadata;
     use crate::fsst_compress_iter;
 
+    #[test]
+    fn slice_reuses_initialized_compressor() -> VortexResult<()> {
+        let symbols = Buffer::<Symbol>::copy_from([
+            Symbol::from_slice(b"abc00000"),
+            Symbol::from_slice(b"defghijk"),
+        ]);
+        let symbol_lengths = Buffer::<u8>::copy_from([3, 8]);
+
+        let compressor = Compressor::rebuild_from(symbols.as_slice(), symbol_lengths.as_slice());
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let fsst_array = fsst_compress_iter(
+            [
+                Some(b"abcabcab".as_ref()),
+                Some(b"defghijk".as_ref()),
+                Some(b"abcxyz".as_ref()),
+            ]
+            .into_iter(),
+            3,
+            DType::Utf8(Nullability::NonNullable),
+            &compressor,
+            &mut ctx,
+        );
+
+        let compressor_ptr = fsst_array.compressor() as *const Compressor;
+        let sliced = fsst_array
+            .slice(1..3)?
+            .try_downcast::<FSST>()
+            .map_err(|_| vortex_err!("slice must return an FSST array"))?;
+        let sliced_compressor_ptr = sliced.compressor() as *const Compressor;
+
+        assert_eq!(compressor_ptr, sliced_compressor_ptr);
+        Ok(())
+    }
+
     #[cfg_attr(miri, ignore)]
     #[test]
     fn test_fsst_metadata() {
diff --git a/encodings/fsst/src/compute/byte_length.rs b/encodings/fsst/src/compute/byte_length.rs
new file mode 100644
index 00000000000..d78bd8be0ec
--- /dev/null
+++ b/encodings/fsst/src/compute/byte_length.rs
@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+use vortex_array::ArrayRef;
+use vortex_array::ArrayView;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
+use vortex_array::ValidityVTable;
+use vortex_array::arrays::ConstantArray;
+use vortex_array::builtins::ArrayBuiltins;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::PType;
+use vortex_array::scalar::Scalar;
+use vortex_array::scalar_fn::fns::byte_length::ByteLengthKernel;
+use vortex_array::validity::Validity;
+use vortex_error::VortexResult;
+
+use crate::FSST;
+use crate::array::FSSTArrayExt;
+
+impl ByteLengthKernel for FSST {
+    fn byte_length(
+        array: ArrayView<'_, Self>,
+        _ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        let nullable = array.dtype().nullability();
+        let dtype = DType::Primitive(PType::U64, nullable);
+        // Uncompressed lengths are non-nullable and may be less than u64 each
+        let lengths = array.uncompressed_lengths().cast(dtype.clone())?;
+        Ok(Some(match FSST::validity(array)? {
+            Validity::NonNullable | Validity::AllValid => lengths,
+            Validity::Array(v) => lengths.mask(v)?,
+            Validity::AllInvalid => {
+                ConstantArray::new(Scalar::null(dtype), lengths.len()).into_array()
+            }
+        }))
+    }
+}
diff --git a/encodings/fsst/src/compute/cast.rs b/encodings/fsst/src/compute/cast.rs
index a1c96363ba0..47c324fc2a4 100644
--- a/encodings/fsst/src/compute/cast.rs
+++ b/encodings/fsst/src/compute/cast.rs
@@ -30,10 +30,9 @@ fn build_with_codes_validity(
     )?;
 
     Ok(unsafe {
-        FSST::new_unchecked(
+        FSST::new_unchecked_with_symbol_table(
             dtype.clone(),
-            array.symbols().clone(),
-            array.symbol_lengths().clone(),
+            array.symbol_table(),
             new_codes,
             array.uncompressed_lengths().clone(),
         )
diff --git a/encodings/fsst/src/compute/filter.rs b/encodings/fsst/src/compute/filter.rs
index 74e32cfbd02..eae72cac8dd 100644
--- a/encodings/fsst/src/compute/filter.rs
+++ b/encodings/fsst/src/compute/filter.rs
@@ -31,10 +31,9 @@ impl FilterKernel for FSST {
             .vortex_expect("must be VarBin");
 
         Ok(Some(
-            FSST::try_new(
+            FSST::try_new_with_symbol_table(
                 array.dtype().clone(),
-                array.symbols().clone(),
-                array.symbol_lengths().clone(),
+                array.symbol_table(),
                 filtered_codes,
                 array.uncompressed_lengths().filter(mask.clone())?,
                 ctx,
diff --git a/encodings/fsst/src/compute/mod.rs b/encodings/fsst/src/compute/mod.rs
index 02efdf7febc..d95725b9fbc 100644
--- a/encodings/fsst/src/compute/mod.rs
+++ b/encodings/fsst/src/compute/mod.rs
@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+mod byte_length;
 mod cast;
 mod compare;
 mod filter;
@@ -28,13 +29,12 @@ impl TakeExecute for FSST {
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>> {
         Ok(Some(
-            FSST::try_new(
+            FSST::try_new_with_symbol_table(
                 array
                     .dtype()
                     .clone()
                     .union_nullability(indices.dtype().nullability()),
-                array.symbols().clone(),
-                array.symbol_lengths().clone(),
+                array.symbol_table(),
                 {
                     let codes = array.codes();
                     let codes = codes.as_view();
diff --git a/encodings/fsst/src/kernel.rs b/encodings/fsst/src/kernel.rs
index 7f455a06e16..386da3b0f60 100644
--- a/encodings/fsst/src/kernel.rs
+++ b/encodings/fsst/src/kernel.rs
@@ -5,6 +5,7 @@ use vortex_array::arrays::dict::TakeExecuteAdaptor;
 use vortex_array::arrays::filter::FilterExecuteAdaptor;
 use vortex_array::kernel::ParentKernelSet;
 use vortex_array::scalar_fn::fns::binary::CompareExecuteAdaptor;
+use vortex_array::scalar_fn::fns::byte_length::ByteLengthExecuteAdaptor;
 use vortex_array::scalar_fn::fns::cast::CastExecuteAdaptor;
 use vortex_array::scalar_fn::fns::like::LikeExecuteAdaptor;
 
@@ -16,6 +17,7 @@ pub(super) const PARENT_KERNELS: ParentKernelSet<FSST> = ParentKernelSet::new(&[
     ParentKernelSet::lift(&FilterExecuteAdaptor(FSST)),
     ParentKernelSet::lift(&TakeExecuteAdaptor(FSST)),
     ParentKernelSet::lift(&LikeExecuteAdaptor(FSST)),
+    ParentKernelSet::lift(&ByteLengthExecuteAdaptor(FSST)),
 ]);
 
 #[cfg(test)]
@@ -27,10 +29,13 @@ mod tests {
     use vortex_array::IntoArray;
     use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::FilterArray;
+    use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::varbin::builder::VarBinBuilder;
     use vortex_array::assert_arrays_eq;
     use vortex_array::dtype::DType;
     use vortex_array::dtype::Nullability;
+    use vortex_array::expr::byte_length;
+    use vortex_array::expr::root;
     use vortex_array::session::ArraySession;
     use vortex_error::VortexResult;
     use vortex_mask::Mask;
@@ -205,4 +210,24 @@ mod tests {
         assert_arrays_eq!(result, fsst_array);
         Ok(())
     }
+
+    #[test]
+    fn test_fsst_byte_length() -> VortexResult<()> {
+        let mut builder = VarBinBuilder::<i32>::with_capacity(3);
+        builder.append_value(b"hello");
+        builder.append_value(b"world!!");
+        builder.append_value("Пуховички"); // 9 characters, 18 bytes
+        builder.append_value(b"");
+
+        let varbin = builder.finish(DType::Utf8(Nullability::NonNullable));
+        let compressor = fsst_train_compressor(&varbin);
+        let len = varbin.len();
+        let dtype = varbin.dtype().clone();
+        let mut ctx = SESSION.create_execution_ctx();
+        let fsst = fsst_compress(varbin, len, &dtype, &compressor, &mut ctx).into_array();
+        let result = fsst.apply(&byte_length(root()))?;
+        let expected = PrimitiveArray::from_iter(vec![5u64, 7, 18, 0]);
+        assert_arrays_eq!(result, expected);
+        Ok(())
+    }
 }
diff --git a/encodings/fsst/src/slice.rs b/encodings/fsst/src/slice.rs
index 9b7b2833d85..b98f5fa03b3 100644
--- a/encodings/fsst/src/slice.rs
+++ b/encodings/fsst/src/slice.rs
@@ -19,10 +19,9 @@ impl SliceReduce for FSST {
         // SAFETY: slicing the `codes` leaves the symbol table intact
         Ok(Some(
             unsafe {
-                FSST::new_unchecked(
+                FSST::new_unchecked_with_symbol_table(
                     array.dtype().clone(),
-                    array.symbols().clone(),
-                    array.symbol_lengths().clone(),
+                    array.symbol_table(),
                     array
                         .codes()
                         .slice(range.clone())?
diff --git a/encodings/fsst/src/tests.rs b/encodings/fsst/src/tests.rs
index c4dca57c61b..481b84865df 100644
--- a/encodings/fsst/src/tests.rs
+++ b/encodings/fsst/src/tests.rs
@@ -1,9 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use rand::SeedableRng;
-use rand::rngs::StdRng;
-use rand::seq::IndexedRandom;
+use fsst::CompressorBuilder;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::LEGACY_SESSION;
@@ -118,12 +116,17 @@ fn test_fsst_array_ops() {
 /// [`VarBinBuilder<i32>`] for the FSST output and panicked in
 /// [`VarBinBuilder::append_value`] once cumulative compressed bytes crossed the boundary.
 ///
-/// The input is built with [`VarBinBuilder<i64>`] so the input itself does not panic, which
-/// confirms the overflow is on the FSST output side. After the fix the test must succeed
-/// with the row count preserved.
+/// The compressor is built with an empty symbol table, so every input byte misses the table
+/// and is escape-coded at exactly two output bytes per input byte. This makes the output
+/// size deterministic and crosses the i32 boundary with roughly half the input bytes that
+/// an incompressible-input construction would need. The input is built with
+/// [`VarBinBuilder<i64>`] so the input itself does not panic, which confirms the overflow
+/// is on the FSST output side. After the fix the test must succeed with the row count
+/// preserved.
 ///
-/// Allocates ~2.5 GiB for the input and ~2.5 GiB for the FSST output (~5 GiB total), so it
-/// is gated to CI runs and skipped when `VORTEX_SKIP_SLOW_TESTS` is set. To run it locally:
+/// Allocates ~1.1 GiB for the input and ~2.1 GiB for the FSST output (~3.2 GiB total), so
+/// it is gated to CI runs and skipped when `VORTEX_SKIP_SLOW_TESTS` is set. To run it
+/// locally:
 ///
 /// ```text
 /// CI=1 cargo test --release -p vortex-fsst fsst_compress_offsets
@@ -133,33 +136,21 @@ fn test_fsst_array_ops() {
 #[test_with::env(CI)]
 #[test_with::no_env(VORTEX_SKIP_SLOW_TESTS)]
 fn fsst_compress_offsets_overflow_i32() {
-    // High-entropy ASCII strings sliced from a random pool. FSST is a symbol-table
-    // compressor; pseudo-random data with no recurring byte sequences resists compression,
-    // so the compressed output stays close to input size and crosses the i32 boundary.
     const STRING_LEN: usize = 64 * 1024;
-    const TOTAL_BYTES: usize = (1usize << 31) + (512 << 20); // ~2.5 GiB
+    // Escape coding doubles every byte, so ~1.06 GiB of input compresses to ~2.13 GiB,
+    // comfortably past i32::MAX.
+    const TOTAL_BYTES: usize = (1usize << 30) + (64 << 20);
     const N: usize = TOTAL_BYTES / STRING_LEN;
-    const POOL_LEN: usize = 64 * 1024 * 1024;
-
-    // Printable ASCII alphabet so the result is valid UTF-8.
-    const ALPHABET: &[u8; 95] =
-        b" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
-
-    let mut rng = StdRng::seed_from_u64(0xC0DE_C011_B711);
-    let pool: Vec<u8> = (0..POOL_LEN)
-        .map(|_| *ALPHABET.choose(&mut rng).unwrap())
-        .collect();
 
     println!("building large VarBinArray");
+    let string = vec![b'a'; STRING_LEN];
     let mut builder = VarBinBuilder::<i64>::with_capacity(N);
-    for i in 0..N {
-        let off = i.wrapping_mul(31337) % (POOL_LEN - STRING_LEN);
-        builder.append_value(&pool[off..off + STRING_LEN]);
+    for _ in 0..N {
+        builder.append_value(&string);
     }
     let array = builder.finish(DType::Utf8(Nullability::NonNullable));
 
-    println!("training FSST compressor");
-    let compressor = fsst_train_compressor(&array);
+    let compressor = CompressorBuilder::default().build();
     let len = array.len();
     let dtype = array.dtype().clone();
     let mut ctx = LEGACY_SESSION.create_execution_ctx();
@@ -167,4 +158,6 @@ fn fsst_compress_offsets_overflow_i32() {
     println!("compressing to FSST");
     let compressed = fsst_compress(array, len, &dtype, &compressor, &mut ctx);
     assert_eq!(compressed.len(), len);
+    // Prove the regression condition was exercised: compressed bytes crossed i32::MAX.
+    assert!(compressed.codes_bytes().len() > i32::MAX as usize);
 }
diff --git a/encodings/parquet-variant/Cargo.toml b/encodings/parquet-variant/Cargo.toml
index 980af8a75a1..6b3900abb27 100644
--- a/encodings/parquet-variant/Cargo.toml
+++ b/encodings/parquet-variant/Cargo.toml
@@ -12,7 +12,6 @@ readme = { workspace = true }
 repository = { workspace = true }
 rust-version = { workspace = true }
 version = { workspace = true }
-publish = false
 
 [lints]
 workspace = true
diff --git a/encodings/parquet-variant/src/array.rs b/encodings/parquet-variant/src/array.rs
index d7004af4ef8..37247430c37 100644
--- a/encodings/parquet-variant/src/array.rs
+++ b/encodings/parquet-variant/src/array.rs
@@ -241,7 +241,7 @@ fn logical_shredded_from_parquet_field(
         let validity = field_struct.validity()?;
         // `unmasked_field_by_name_opt` intentionally ignores the parent struct validity.
         // Reapply it here so null wrapper rows become null typed/raw rows downstream.
-        let typed_value = if validity.no_nulls() {
+        let typed_value = if validity.definitely_no_nulls() {
             typed_value.clone()
         } else {
             typed_value
@@ -251,7 +251,7 @@ fn logical_shredded_from_parquet_field(
         let value = field_struct
             .unmasked_field_by_name_opt("value")
             .map(|value| {
-                if validity.no_nulls() {
+                if validity.definitely_no_nulls() {
                     Ok(value.clone())
                 } else {
                     value.clone().mask(validity.to_array(value.len()))
diff --git a/encodings/parquet-variant/src/arrow.rs b/encodings/parquet-variant/src/arrow.rs
index 9af18c86ebb..9bee5c738d3 100644
--- a/encodings/parquet-variant/src/arrow.rs
+++ b/encodings/parquet-variant/src/arrow.rs
@@ -18,6 +18,8 @@ use vortex_array::ArrayRef;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
 use vortex_array::VTable;
+use vortex_array::arrays::Variant;
+use vortex_array::arrays::variant::VariantArrayExt;
 use vortex_array::arrow::ArrowExport;
 use vortex_array::arrow::ArrowExportVTable;
 use vortex_array::arrow::ArrowImport;
@@ -113,6 +115,35 @@ fn export_unshredded_storage_to_target<T: ParquetVariantArrayExt>(
     export_storage_to_target(&unshredded_parquet, target_fields, ctx)
 }
 
+fn parquet_variant_for_export(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
+    let executed = array.execute_until::<ParquetVariant>(ctx)?;
+    if executed.is::<ParquetVariant>() {
+        return Ok(executed);
+    }
+
+    let variant = executed
+        .as_opt::<Variant>()
+        .ok_or_else(|| vortex_err!("cannot export Variant without ParquetVariant storage"))?;
+    let core_storage = variant
+        .core_storage()
+        .clone()
+        .execute_until::<ParquetVariant>(ctx)?;
+    let parquet_core = core_storage
+        .as_opt::<ParquetVariant>()
+        .ok_or_else(|| vortex_err!("cannot export Variant without ParquetVariant core storage"))?;
+    let Some(shredded) = variant.shredded() else {
+        return Ok(core_storage);
+    };
+
+    ParquetVariant::try_new(
+        ParquetVariantArrayExt::validity(&parquet_core),
+        parquet_core.metadata_array().clone(),
+        parquet_core.value_array().cloned(),
+        Some(shredded.clone()),
+    )
+    .map(IntoArray::into_array)
+}
+
 impl ArrowExportVTable for ParquetVariant {
     fn arrow_ext_id(&self) -> Id {
         *ARROW_PARQUET_VARIANT
@@ -148,10 +179,8 @@ impl ArrowExportVTable for ParquetVariant {
             return Ok(ArrowExport::Unsupported(array));
         }
 
-        let executed = array.execute_until::<ParquetVariant>(ctx)?;
-        let parquet_array = executed
-            .as_opt::<ParquetVariant>()
-            .ok_or_else(|| vortex_err!("cannot export Variant without ParquetVariant storage"))?;
+        let parquet_array = parquet_variant_for_export(array, ctx)?;
+        let parquet_array = parquet_array.as_::<ParquetVariant>();
 
         if let DataType::Struct(fields) = target.data_type()
             && let Some((request_has_value, request_has_typed_value)) =
@@ -261,6 +290,7 @@ mod tests {
     use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::VarBinViewArray;
+    use vortex_array::arrays::VariantArray;
     use vortex_array::arrow::ArrowSessionExt;
     use vortex_array::assert_arrays_eq;
     use vortex_array::dtype::DType;
@@ -359,6 +389,77 @@ mod tests {
         Ok(())
     }
 
+    #[rstest]
+    fn export_canonical_variant_with_parquet_variant_core_storage(
+        session: VortexSession,
+    ) -> VortexResult<()> {
+        let storage = arrow_variant_storage();
+        let field = arrow_variant_field(&storage);
+        let core_storage = session
+            .arrow()
+            .from_arrow_array(Arc::new(storage.clone()) as ArrowArrayRef, &field)?;
+        let canonical = VariantArray::try_new(core_storage, None)?.into_array();
+
+        let mut ctx = session.create_execution_ctx();
+        let exported = session
+            .arrow()
+            .execute_arrow(canonical, Some(&field), &mut ctx)?;
+        let exported = exported.as_struct();
+
+        assert_struct_arrays_eq(exported, &storage);
+        Ok(())
+    }
+
+    #[rstest]
+    fn export_canonical_variant_reattaches_shredded_child(
+        session: VortexSession,
+    ) -> VortexResult<()> {
+        let rows = [
+            VariantBuilder::new().with_value(10i32).finish(),
+            VariantBuilder::new().with_value(20i32).finish(),
+            VariantBuilder::new().with_value(30i32).finish(),
+        ];
+        let metadata =
+            VarBinViewArray::from_iter_bin(rows.iter().map(|(metadata, _)| metadata.as_slice()))
+                .into_array();
+        let typed_value = buffer![10i32, 20, 30].into_array();
+        let expected =
+            ParquetVariant::try_new(Validity::NonNullable, metadata, None, Some(typed_value))?
+                .into_array();
+
+        let mut ctx = session.create_execution_ctx();
+        let canonical = expected
+            .clone()
+            .execute::<VariantArray>(&mut ctx)?
+            .into_array();
+        let field = Field::new(
+            "variant",
+            DataType::Struct(
+                vec![
+                    Field::new("metadata", DataType::BinaryView, false),
+                    Field::new("value", DataType::BinaryView, false),
+                ]
+                .into(),
+            ),
+            false,
+        )
+        .with_metadata(
+            [(
+                EXTENSION_TYPE_NAME_KEY.to_string(),
+                PARQUET_VARIANT_ARROW_EXTENSION_NAME.to_string(),
+            )]
+            .into(),
+        );
+
+        let exported = session
+            .arrow()
+            .execute_arrow(canonical, Some(&field), &mut ctx)?;
+        assert_eq!(exported.data_type(), field.data_type());
+
+        let actual = session.arrow().from_arrow_array(exported, &field)?;
+        assert_variant_scalars_eq(&actual, &expected, &session)
+    }
+
     #[rstest]
     fn roundtrip_parquet_variant_extension_array_from_vortex(
         session: VortexSession,
diff --git a/encodings/parquet-variant/src/operations.rs b/encodings/parquet-variant/src/operations.rs
index 897c7fca3bb..10f11e2bf2c 100644
--- a/encodings/parquet-variant/src/operations.rs
+++ b/encodings/parquet-variant/src/operations.rs
@@ -41,7 +41,7 @@ impl OperationsVTable<ParquetVariant> for ParquetVariant {
         index: usize,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Scalar> {
-        if array.validity()?.is_null(index)? {
+        if array.validity()?.execute_is_null(index, ctx)? {
             return Ok(Scalar::null(DType::Variant(Nullability::Nullable)));
         }
 
diff --git a/encodings/parquet-variant/src/vtable.rs b/encodings/parquet-variant/src/vtable.rs
index 40f8dbb0604..f2ad4f64743 100644
--- a/encodings/parquet-variant/src/vtable.rs
+++ b/encodings/parquet-variant/src/vtable.rs
@@ -308,9 +308,9 @@ mod tests {
     use vortex_array::ArrayEq;
     use vortex_array::ArrayRef;
     use vortex_array::Canonical;
+    use vortex_array::EqMode;
     use vortex_array::IntoArray;
     use vortex_array::LEGACY_SESSION;
-    use vortex_array::Precision;
     use vortex_array::VTable;
     use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::PrimitiveArray;
@@ -525,7 +525,7 @@ mod tests {
         let array = outer_pv.into_array();
         let decoded = roundtrip(array.clone())?;
 
-        assert!(array.array_eq(&decoded, Precision::Value));
+        assert!(array.array_eq(&decoded, EqMode::Value));
         let decoded_pv = decoded
             .as_opt::<ParquetVariant>()
             .ok_or_else(|| vortex_err!("expected parquet variant array"))?;
@@ -547,7 +547,7 @@ mod tests {
         let array = pv.into_array();
         let decoded = roundtrip(array.clone())?;
 
-        assert!(array.array_eq(&decoded, Precision::Value));
+        assert!(array.array_eq(&decoded, EqMode::Value));
         assert_eq!(decoded.dtype(), &DType::Variant(Nullability::Nullable));
         let decoded_pv = decoded
             .as_opt::<ParquetVariant>()
@@ -572,7 +572,7 @@ mod tests {
         let array = outer_pv.into_array();
         let decoded = roundtrip(array.clone())?;
 
-        assert!(array.array_eq(&decoded, Precision::Value));
+        assert!(array.array_eq(&decoded, EqMode::Value));
         let decoded_pv = decoded
             .as_opt::<ParquetVariant>()
             .ok_or_else(|| vortex_err!("expected parquet variant array"))?;
diff --git a/encodings/pco/src/array.rs b/encodings/pco/src/array.rs
index 94db1014c79..df2d79f63f1 100644
--- a/encodings/pco/src/array.rs
+++ b/encodings/pco/src/array.rs
@@ -25,10 +25,10 @@ use vortex_array::ArrayId;
 use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
 use vortex_array::ArrayView;
+use vortex_array::EqMode;
 use vortex_array::ExecutionCtx;
 use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
-use vortex_array::Precision;
 use vortex_array::arrays::Primitive;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::buffer::BufferHandle;
@@ -83,22 +83,22 @@ const VALUES_PER_CHUNK: usize = pco::DEFAULT_MAX_PAGE_N;
 pub type PcoArray = Array<Pco>;
 
 impl ArrayHash for PcoData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, accuracy: EqMode) {
         self.unsliced_n_rows.hash(state);
         self.slice_start.hash(state);
         self.slice_stop.hash(state);
         // Hash chunk_metas and pages using pointer-based hashing
         for chunk_meta in &self.chunk_metas {
-            chunk_meta.array_hash(state, precision);
+            chunk_meta.array_hash(state, accuracy);
         }
         for page in &self.pages {
-            page.array_hash(state, precision);
+            page.array_hash(state, accuracy);
         }
     }
 }
 
 impl ArrayEq for PcoData {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, accuracy: EqMode) -> bool {
         if self.unsliced_n_rows != other.unsliced_n_rows
             || self.slice_start != other.slice_start
             || self.slice_stop != other.slice_stop
@@ -108,12 +108,12 @@ impl ArrayEq for PcoData {
             return false;
         }
         for (a, b) in self.chunk_metas.iter().zip(&other.chunk_metas) {
-            if !a.array_eq(b, precision) {
+            if !a.array_eq(b, accuracy) {
                 return false;
             }
         }
         for (a, b) in self.pages.iter().zip(&other.pages) {
-            if !a.array_eq(b, precision) {
+            if !a.array_eq(b, accuracy) {
                 return false;
             }
         }
diff --git a/encodings/pco/src/tests.rs b/encodings/pco/src/tests.rs
index 6e5b4f9841b..20fec7dd9e0 100644
--- a/encodings/pco/src/tests.rs
+++ b/encodings/pco/src/tests.rs
@@ -149,6 +149,7 @@ fn test_validity_and_multiple_chunks_and_pages() {
             .unwrap()
             .mask_eq(
                 &Validity::Array(BoolArray::from_iter(vec![true, false, true]).into_array()),
+                primitive.len(),
                 &mut ctx,
             )
             .unwrap()
diff --git a/encodings/runend/benches/run_end_compress.rs b/encodings/runend/benches/run_end_compress.rs
index 1c183f3e5fd..a49a5cfcb50 100644
--- a/encodings/runend/benches/run_end_compress.rs
+++ b/encodings/runend/benches/run_end_compress.rs
@@ -3,24 +3,30 @@
 
 #![expect(clippy::unwrap_used)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use itertools::repeat_n;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::RecursiveCanonical;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::VarBinViewArray;
 use vortex_array::dtype::IntegerPType;
+use vortex_array::session::ArraySession;
 use vortex_array::validity::Validity;
 use vortex_buffer::Buffer;
 use vortex_runend::RunEnd;
 use vortex_runend::compress::runend_encode;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
 }
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 const BENCH_ARGS: &[(usize, usize)] = &[
     (1000, 4),
     (1000, 16),
@@ -47,7 +53,7 @@ fn compress(bencher: Bencher, (length, run_step): (usize, usize)) {
     );
 
     bencher
-        .with_inputs(|| (&values, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&values, SESSION.create_execution_ctx()))
         .bench_refs(|(values, ctx)| runend_encode(values.as_view(), ctx));
 }
 
@@ -64,11 +70,11 @@ fn decompress<T: IntegerPType>(bencher: Bencher, (length, run_step): (usize, usi
         .collect::<Buffer<_>>()
         .into_array();
 
-    let run_end_array = RunEnd::new(ends, values, &mut LEGACY_SESSION.create_execution_ctx());
+    let run_end_array = RunEnd::new(ends, values, &mut SESSION.create_execution_ctx());
     let array = run_end_array.into_array();
 
     bencher
-        .with_inputs(|| (array.clone(), LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (array.clone(), SESSION.create_execution_ctx()))
         .bench_values(|(array, mut execution_ctx)| {
             array
                 .execute::<RecursiveCanonical>(&mut execution_ctx)
@@ -88,20 +94,14 @@ fn take_indices(bencher: Bencher, (length, run_step): (usize, usize)) {
     );
 
     let source_array = PrimitiveArray::from_iter(0..(length as i32)).into_array();
-    let mut encode_ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut encode_ctx = SESSION.create_execution_ctx();
     let (ends, values) = runend_encode(values.as_view(), &mut encode_ctx);
     let runend_array = RunEnd::try_new(ends.into_array(), values, &mut encode_ctx)
         .unwrap()
         .into_array();
 
     bencher
-        .with_inputs(|| {
-            (
-                &source_array,
-                &runend_array,
-                LEGACY_SESSION.create_execution_ctx(),
-            )
-        })
+        .with_inputs(|| (&source_array, &runend_array, SESSION.create_execution_ctx()))
         .bench_refs(|(array, indices, execution_ctx)| {
             array
                 .take(indices.clone())
@@ -122,11 +122,11 @@ fn decompress_utf8(bencher: Bencher, (length, run_step): (usize, usize)) {
     let values = VarBinViewArray::from_iter_str((0..num_runs).map(|i| format!("run_value_{i}")))
         .into_array();
 
-    let run_end_array = RunEnd::new(ends, values, &mut LEGACY_SESSION.create_execution_ctx());
+    let run_end_array = RunEnd::new(ends, values, &mut SESSION.create_execution_ctx());
     let array = run_end_array.into_array();
 
     bencher
-        .with_inputs(|| (array.clone(), LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (array.clone(), SESSION.create_execution_ctx()))
         .bench_values(|(array, mut execution_ctx)| {
             array
                 .execute::<RecursiveCanonical>(&mut execution_ctx)
diff --git a/encodings/runend/benches/run_end_decode.rs b/encodings/runend/benches/run_end_decode.rs
index 818c8eb4ed6..f509e55aed3 100644
--- a/encodings/runend/benches/run_end_decode.rs
+++ b/encodings/runend/benches/run_end_decode.rs
@@ -4,21 +4,26 @@
 #![expect(clippy::cast_possible_truncation)]
 
 use std::fmt;
+use std::sync::LazyLock;
 
 use divan::Bencher;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::BoolArray;
 use vortex_array::arrays::PrimitiveArray;
+use vortex_array::session::ArraySession;
 use vortex_array::validity::Validity;
 use vortex_buffer::BitBuffer;
 use vortex_buffer::BufferMut;
 use vortex_runend::decompress_bool::runend_decode_bools;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
 }
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 /// Distribution types for bool benchmarks
 #[derive(Clone, Copy)]
 enum BoolDistribution {
@@ -210,13 +215,7 @@ fn decode_bool(bencher: Bencher, args: BoolBenchArgs) {
     } = args;
     let (ends, values) = create_bool_test_data(total_length, avg_run_length, distribution);
     bencher
-        .with_inputs(|| {
-            (
-                ends.clone(),
-                values.clone(),
-                LEGACY_SESSION.create_execution_ctx(),
-            )
-        })
+        .with_inputs(|| (ends.clone(), values.clone(), SESSION.create_execution_ctx()))
         .bench_refs(|(ends, values, ctx)| {
             runend_decode_bools(ends.clone(), values.clone(), 0, total_length, ctx)
         });
@@ -379,13 +378,7 @@ fn decode_bool_nullable(bencher: Bencher, args: NullableBoolBenchArgs) {
     let (ends, values) =
         create_nullable_bool_test_data(total_length, avg_run_length, distribution, validity);
     bencher
-        .with_inputs(|| {
-            (
-                ends.clone(),
-                values.clone(),
-                LEGACY_SESSION.create_execution_ctx(),
-            )
-        })
+        .with_inputs(|| (ends.clone(), values.clone(), SESSION.create_execution_ctx()))
         .bench_refs(|(ends, values, ctx)| {
             runend_decode_bools(ends.clone(), values.clone(), 0, total_length, ctx)
         });
diff --git a/encodings/runend/benches/run_end_null_count.rs b/encodings/runend/benches/run_end_null_count.rs
index c60c72c5e0e..5392e04189b 100644
--- a/encodings/runend/benches/run_end_null_count.rs
+++ b/encodings/runend/benches/run_end_null_count.rs
@@ -3,17 +3,20 @@
 
 #![expect(clippy::unwrap_used)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use rand::RngExt;
 use rand::SeedableRng;
 use rand::rngs::StdRng;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::PrimitiveArray;
+use vortex_array::session::ArraySession;
 use vortex_buffer::Buffer;
 use vortex_runend::RunEnd;
 use vortex_runend::RunEndArray;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
@@ -47,15 +50,16 @@ const BENCH_ARGS: &[(usize, usize, f64)] = &[
     (100_000, 1024, 0.5),
 ];
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 #[divan::bench(args = BENCH_ARGS)]
 fn null_count_run_end(bencher: Bencher, (n, run_step, valid_density): (usize, usize, f64)) {
     let array = fixture(n, run_step, valid_density).into_array();
 
-    bencher.with_inputs(|| &array).bench_refs(|array| {
-        array
-            .invalid_count(&mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
-    });
+    bencher
+        .with_inputs(|| (&array, SESSION.create_execution_ctx()))
+        .bench_refs(|(array, ctx)| array.invalid_count(ctx).unwrap());
 }
 
 fn fixture(n: usize, run_step: usize, valid_density: f64) -> RunEndArray {
@@ -72,5 +76,5 @@ fn fixture(n: usize, run_step: usize, valid_density: f64) -> RunEndArray {
     )
     .into_array();
 
-    RunEnd::new(ends, values, &mut LEGACY_SESSION.create_execution_ctx())
+    RunEnd::new(ends, values, &mut SESSION.create_execution_ctx())
 }
diff --git a/encodings/runend/src/array.rs b/encodings/runend/src/array.rs
index 943f4881806..7bb069bb458 100644
--- a/encodings/runend/src/array.rs
+++ b/encodings/runend/src/array.rs
@@ -15,11 +15,11 @@ use vortex_array::ArrayId;
 use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
 use vortex_array::ArrayView;
+use vortex_array::EqMode;
 use vortex_array::ExecutionCtx;
 use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::LEGACY_SESSION;
-use vortex_array::Precision;
 use vortex_array::TypedArrayRef;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::Primitive;
@@ -65,13 +65,13 @@ pub struct RunEndMetadata {
 }
 
 impl ArrayHash for RunEndData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _accuracy: EqMode) {
         self.offset.hash(state);
     }
 }
 
 impl ArrayEq for RunEndData {
-    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, _accuracy: EqMode) -> bool {
         self.offset == other.offset
     }
 }
diff --git a/encodings/runend/src/rules.rs b/encodings/runend/src/rules.rs
index cd80e42db46..ac7d6038146 100644
--- a/encodings/runend/src/rules.rs
+++ b/encodings/runend/src/rules.rs
@@ -77,8 +77,7 @@ impl ArrayParentReduceRule<RunEnd> for RunEndScalarFnRule {
         }
 
         let new_values =
-            ScalarFnArray::try_new(parent.scalar_fn().clone(), new_children, values_len)?
-                .into_array();
+            ScalarFnArray::try_new(parent.scalar_fn().clone(), new_children)?.into_array();
 
         Ok(Some(
             unsafe {
diff --git a/encodings/sequence/src/array.rs b/encodings/sequence/src/array.rs
index a572a5fc165..af8b146cfba 100644
--- a/encodings/sequence/src/array.rs
+++ b/encodings/sequence/src/array.rs
@@ -16,9 +16,9 @@ use vortex_array::ArrayId;
 use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
 use vortex_array::ArrayView;
+use vortex_array::EqMode;
 use vortex_array::ExecutionCtx;
 use vortex_array::ExecutionResult;
-use vortex_array::Precision;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::NativePType;
@@ -214,14 +214,14 @@ impl SequenceData {
 }
 
 impl ArrayHash for SequenceData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _accuracy: EqMode) {
         self.base.hash(state);
         self.multiplier.hash(state);
     }
 }
 
 impl ArrayEq for SequenceData {
-    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, _accuracy: EqMode) -> bool {
         self.base == other.base && self.multiplier == other.multiplier
     }
 }
diff --git a/encodings/sparse/benches/sparse_canonical.rs b/encodings/sparse/benches/sparse_canonical.rs
index ba1489a0e5a..3861e26da06 100644
--- a/encodings/sparse/benches/sparse_canonical.rs
+++ b/encodings/sparse/benches/sparse_canonical.rs
@@ -4,12 +4,12 @@
 #![expect(clippy::cast_possible_truncation)]
 
 use std::sync::Arc;
+use std::sync::LazyLock;
 
 use divan::Bencher;
 use vortex_array::ArrayRef;
 use vortex_array::Canonical;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::FixedSizeListArray;
 use vortex_array::arrays::ListViewArray;
@@ -17,15 +17,20 @@ use vortex_array::arrays::PrimitiveArray;
 use vortex_array::dtype::Nullability::NonNullable;
 use vortex_array::dtype::PType::I32;
 use vortex_array::scalar::Scalar;
+use vortex_array::session::ArraySession;
 use vortex_array::validity::Validity;
 use vortex_buffer::Buffer;
 use vortex_error::VortexExpect;
+use vortex_session::VortexSession;
 use vortex_sparse::Sparse;
 
 fn main() {
     divan::main();
 }
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 const LIST_ARGS: &[(usize, usize, usize)] = &[
     // len, patch_stride, list_size
     (512, 7, 4),
@@ -93,7 +98,7 @@ fn canonicalize_sparse_list(
     let sparse = make_sparse_list(len, patch_stride, list_size);
 
     bencher
-        .with_inputs(|| (sparse.clone(), LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (sparse.clone(), SESSION.create_execution_ctx()))
         .bench_values(|(array, mut ctx)| {
             divan::black_box(
                 array
@@ -111,7 +116,7 @@ fn canonicalize_sparse_fixed_size_list(
     let sparse = make_sparse_fixed_size_list(len, patch_stride, list_size);
 
     bencher
-        .with_inputs(|| (sparse.clone(), LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (sparse.clone(), SESSION.create_execution_ctx()))
         .bench_values(|(array, mut ctx)| {
             divan::black_box(
                 array
diff --git a/encodings/sparse/src/canonical.rs b/encodings/sparse/src/canonical.rs
index ac8c072e7b1..dd84123851a 100644
--- a/encodings/sparse/src/canonical.rs
+++ b/encodings/sparse/src/canonical.rs
@@ -226,7 +226,11 @@ fn execute_sparse_lists_inner<I: IntegerPType, O: IntegerPType>(
 
     let mut next_index = 0;
 
-    for (patch_idx, sparse_idx) in patch_indices.iter().enumerate() {
+    for ((patch_idx, sparse_idx), patch_valid) in patch_indices
+        .iter()
+        .enumerate()
+        .zip(patch_values_validity.iter())
+    {
         let sparse_idx = sparse_idx
             .to_usize()
             .vortex_expect("patch index must fit in usize");
@@ -237,7 +241,7 @@ fn execute_sparse_lists_inner<I: IntegerPType, O: IntegerPType>(
             sparse_idx - next_index,
         );
 
-        if patch_values_validity.value(patch_idx) {
+        if patch_valid {
             let patch_list = patch_values
                 .list_elements_at(patch_idx)
                 .vortex_expect("list_elements_at");
@@ -318,7 +322,7 @@ fn execute_sparse_fixed_size_list_inner<I: IntegerPType>(
         .iter()
         .map(|x| (*x).to_usize().vortex_expect("index must fit in usize"));
 
-    for (patch_idx, sparse_idx) in indices.enumerate() {
+    for ((patch_idx, sparse_idx), patch_valid) in indices.enumerate().zip(values_validity.iter()) {
         // Fill gap before this patch with fill values.
         append_fixed_size_list_fill(
             &mut builder,
@@ -327,7 +331,7 @@ fn execute_sparse_fixed_size_list_inner<I: IntegerPType>(
         );
 
         // Append the patch value, handling null patches by appending defaults.
-        if values_validity.value(patch_idx) {
+        if patch_valid {
             let patch_list = values
                 .fixed_size_list_elements_at(patch_idx)
                 .vortex_expect("fixed_size_list_elements_at");
diff --git a/encodings/sparse/src/lib.rs b/encodings/sparse/src/lib.rs
index 42b5cd46724..e74cedb942e 100644
--- a/encodings/sparse/src/lib.rs
+++ b/encodings/sparse/src/lib.rs
@@ -19,10 +19,10 @@ use vortex_array::ArrayRef;
 use vortex_array::ArraySlots;
 use vortex_array::ArrayView;
 use vortex_array::Canonical;
+use vortex_array::EqMode;
 use vortex_array::ExecutionCtx;
 use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
-use vortex_array::Precision;
 use vortex_array::arrays::BoolArray;
 use vortex_array::arrays::ConstantArray;
 use vortex_array::arrays::Primitive;
@@ -165,7 +165,7 @@ pub struct SparseMetadata {
 }
 
 impl ArrayHash for SparseData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _accuracy: EqMode) {
         self.array_len.hash(state);
         self.patches_data.hash(state);
         self.fill_value.hash(state);
@@ -173,7 +173,7 @@ impl ArrayHash for SparseData {
 }
 
 impl ArrayEq for SparseData {
-    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, _accuracy: EqMode) -> bool {
         self.array_len == other.array_len
             && self.patches_data == other.patches_data
             && self.fill_value == other.fill_value
diff --git a/encodings/zigzag/src/array.rs b/encodings/zigzag/src/array.rs
index 26d3bf984e2..f03315ae575 100644
--- a/encodings/zigzag/src/array.rs
+++ b/encodings/zigzag/src/array.rs
@@ -12,10 +12,10 @@ use vortex_array::ArrayId;
 use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
 use vortex_array::ArrayView;
+use vortex_array::EqMode;
 use vortex_array::ExecutionCtx;
 use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
-use vortex_array::Precision;
 use vortex_array::TypedArrayRef;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::DType;
@@ -155,11 +155,11 @@ impl VTable for ZigZag {
 }
 
 impl ArrayHash for ZigZagData {
-    fn array_hash<H: Hasher>(&self, _state: &mut H, _precision: Precision) {}
+    fn array_hash<H: Hasher>(&self, _state: &mut H, _accuracy: EqMode) {}
 }
 
 impl ArrayEq for ZigZagData {
-    fn array_eq(&self, _other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, _other: &Self, _accuracy: EqMode) -> bool {
         true
     }
 }
diff --git a/encodings/zstd/benches/listview_rebuild.rs b/encodings/zstd/benches/listview_rebuild.rs
index 4b8ca95eafc..fe4e9f063d1 100644
--- a/encodings/zstd/benches/listview_rebuild.rs
+++ b/encodings/zstd/benches/listview_rebuild.rs
@@ -3,18 +3,25 @@
 
 #![expect(clippy::unwrap_used)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::ListViewArray;
 use vortex_array::arrays::VarBinViewArray;
 use vortex_array::arrays::listview::ListViewRebuildMode;
+use vortex_array::session::ArraySession;
 use vortex_array::validity::Validity;
 use vortex_buffer::Buffer;
+use vortex_session::VortexSession;
 use vortex_zstd::Zstd;
 use vortex_zstd::ZstdData;
 
+/// A shared session for the `ListView` rebuild benchmark, used to create execution contexts.
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 #[divan::bench(sample_size = 1000)]
 fn rebuild_naive(bencher: Bencher) {
     let dudes = VarBinViewArray::from_iter_str(["Washington", "Adams", "Jefferson", "Madison"])
@@ -23,7 +30,7 @@ fn rebuild_naive(bencher: Bencher) {
     let validity = dudes.validity().unwrap();
     let dudes = Zstd::try_new(
         dtype,
-        ZstdData::from_array(dudes, 9, 1024, &mut LEGACY_SESSION.create_execution_ctx()).unwrap(),
+        ZstdData::from_array(dudes, 9, 1024, &mut SESSION.create_execution_ctx()).unwrap(),
         validity,
     )
     .unwrap()
@@ -42,8 +49,10 @@ fn rebuild_naive(bencher: Bencher) {
     let list_view = ListViewArray::new(dudes, offsets, sizes, Validity::NonNullable);
 
     bencher
-        .with_inputs(|| &list_view)
-        .bench_refs(|list_view| list_view.rebuild(ListViewRebuildMode::MakeZeroCopyToList))
+        .with_inputs(|| (&list_view, SESSION.create_execution_ctx()))
+        .bench_refs(|(list_view, ctx)| {
+            list_view.rebuild(ListViewRebuildMode::MakeZeroCopyToList, ctx)
+        })
 }
 
 fn main() {
diff --git a/encodings/zstd/src/array.rs b/encodings/zstd/src/array.rs
index b327a6a2a95..0e3bccc4667 100644
--- a/encodings/zstd/src/array.rs
+++ b/encodings/zstd/src/array.rs
@@ -18,10 +18,10 @@ use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
 use vortex_array::ArrayView;
 use vortex_array::Canonical;
+use vortex_array::EqMode;
 use vortex_array::ExecutionCtx;
 use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
-use vortex_array::Precision;
 use vortex_array::accessor::ArrayAccessor;
 use vortex_array::arrays::ConstantArray;
 use vortex_array::arrays::PrimitiveArray;
@@ -84,18 +84,18 @@ type ViewLen = u32;
 pub type ZstdArray = Array<Zstd>;
 
 impl ArrayHash for ZstdData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, accuracy: EqMode) {
         match &self.dictionary {
             Some(dict) => {
                 true.hash(state);
-                dict.array_hash(state, precision);
+                dict.array_hash(state, accuracy);
             }
             None => {
                 false.hash(state);
             }
         }
         for frame in &self.frames {
-            frame.array_hash(state, precision);
+            frame.array_hash(state, accuracy);
         }
         self.unsliced_n_rows.hash(state);
         self.slice_start.hash(state);
@@ -104,9 +104,9 @@ impl ArrayHash for ZstdData {
 }
 
 impl ArrayEq for ZstdData {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, accuracy: EqMode) -> bool {
         if !match (&self.dictionary, &other.dictionary) {
-            (Some(d1), Some(d2)) => d1.array_eq(d2, precision),
+            (Some(d1), Some(d2)) => d1.array_eq(d2, accuracy),
             (None, None) => true,
             _ => false,
         } {
@@ -116,7 +116,7 @@ impl ArrayEq for ZstdData {
             return false;
         }
         for (a, b) in self.frames.iter().zip(&other.frames) {
-            if !a.array_eq(b, precision) {
+            if !a.array_eq(b, accuracy) {
                 return false;
             }
         }
@@ -354,7 +354,7 @@ pub struct ZstdDataParts {
     pub slice_stop: usize,
 }
 
-/// The parts of a [`ZstdArray`] returned by [`ZstdArray::into_parts`].
+/// Compressed ZStd frames and their metadata
 #[derive(Debug)]
 struct Frames {
     dictionary: Option<ByteBuffer>,
diff --git a/encodings/zstd/src/compute/cast.rs b/encodings/zstd/src/compute/cast.rs
index e295e556566..6cbe4f37795 100644
--- a/encodings/zstd/src/compute/cast.rs
+++ b/encodings/zstd/src/compute/cast.rs
@@ -41,7 +41,7 @@ impl CastReduce for Zstd {
                     child_to_validity(array.slots()[0].as_ref(), array.dtype().nullability());
                 let has_nulls = !unsliced_validity
                     .slice(array.slice_start()..array.slice_stop())?
-                    .no_nulls();
+                    .definitely_no_nulls();
 
                 // We don't attempt to handle casting when there are nulls.
                 if has_nulls {
diff --git a/encodings/zstd/src/test.rs b/encodings/zstd/src/test.rs
index 7ed22886b82..094c5ef60cc 100644
--- a/encodings/zstd/src/test.rs
+++ b/encodings/zstd/src/test.rs
@@ -89,7 +89,7 @@ fn test_zstd_with_validity_and_multi_frame() {
         decompressed
             .validity()
             .unwrap()
-            .mask_eq(&array.validity().unwrap(), &mut ctx)
+            .mask_eq(&array.validity().unwrap(), decompressed.len(), &mut ctx)
             .unwrap()
     );
 
@@ -106,6 +106,7 @@ fn test_zstd_with_validity_and_multi_frame() {
             .unwrap()
             .mask_eq(
                 &Validity::Array(BoolArray::from_iter(vec![false, true, false]).into_array()),
+                primitive.len(),
                 &mut ctx
             )
             .unwrap()
diff --git a/encodings/zstd/src/zstd_buffers.rs b/encodings/zstd/src/zstd_buffers.rs
index 597817456f2..dd689fd76bd 100644
--- a/encodings/zstd/src/zstd_buffers.rs
+++ b/encodings/zstd/src/zstd_buffers.rs
@@ -17,9 +17,9 @@ use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
 use vortex_array::ArraySlots;
 use vortex_array::ArrayView;
+use vortex_array::EqMode;
 use vortex_array::ExecutionCtx;
 use vortex_array::ExecutionResult;
-use vortex_array::Precision;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::DType;
 use vortex_array::scalar::Scalar;
@@ -337,11 +337,11 @@ fn array_id_from_string(s: &str) -> ArrayId {
 }
 
 impl ArrayHash for ZstdBuffersData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, accuracy: EqMode) {
         self.inner_encoding_id.hash(state);
         self.inner_metadata.hash(state);
         for buf in &self.compressed_buffers {
-            buf.array_hash(state, precision);
+            buf.array_hash(state, accuracy);
         }
         self.uncompressed_sizes.hash(state);
         self.buffer_alignments.hash(state);
@@ -349,7 +349,7 @@ impl ArrayHash for ZstdBuffersData {
 }
 
 impl ArrayEq for ZstdBuffersData {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, accuracy: EqMode) -> bool {
         self.inner_encoding_id == other.inner_encoding_id
             && self.inner_metadata == other.inner_metadata
             && self.compressed_buffers.len() == other.compressed_buffers.len()
@@ -357,7 +357,7 @@ impl ArrayEq for ZstdBuffersData {
                 .compressed_buffers
                 .iter()
                 .zip(&other.compressed_buffers)
-                .all(|(a, b)| a.array_eq(b, precision))
+                .all(|(a, b)| a.array_eq(b, accuracy))
             && self.uncompressed_sizes == other.uncompressed_sizes
             && self.buffer_alignments == other.buffer_alignments
     }
diff --git a/java/build.gradle.kts b/java/build.gradle.kts
index 73ea3108418..43cc24b48ed 100644
--- a/java/build.gradle.kts
+++ b/java/build.gradle.kts
@@ -61,7 +61,7 @@ allprojects {
         }
 
         tasks.withType<Javadoc> {
-            (options as StandardJavadocDocletOptions).addStringOption("Xdoclint:-missing")
+            (options as StandardJavadocDocletOptions).addBooleanOption("Xdoclint:-missing", true)
         }
 
         the<JavaPluginExtension>().toolchain {
diff --git a/java/gradle/libs.versions.toml b/java/gradle/libs.versions.toml
index 464f6339603..1135946d4ab 100644
--- a/java/gradle/libs.versions.toml
+++ b/java/gradle/libs.versions.toml
@@ -7,9 +7,10 @@ errorprone = "2.36.0"
 guava = "33.6.0-jre"
 immutables = "2.12.2"
 junit-jupiter = "6.1.0"
-logback = "1.5.33"
-netty = "4.2.14.Final"
+logback = "1.5.34"
+netty = "4.2.15.Final"
 nopen = "1.0.1"
+roaringbitmap = "1.6.14"
 slf4j = "2.0.18"
 spark3 = "3.5.8"
 spark4 = "4.1.1"
@@ -30,7 +31,8 @@ logback-classic = { module = "ch.qos.logback:logback-classic", version.ref = "lo
 netty-bom = { module = "io.netty:netty-bom", version.ref = "netty" }
 nopen-annotations = { module = "com.jakewharton.nopen:nopen-annotations", version.ref = "nopen" }
 nopen-checker = { module = "com.jakewharton.nopen:nopen-checker", version.ref = "nopen" }
+roaringbitmap = { module = "org.roaringbitmap:RoaringBitmap", version.ref = "roaringbitmap" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }
 slf4j-simple = { module = "org.slf4j:slf4j-simple", version.ref = "slf4j" }
 s3mock-testcontainers = { module = "com.adobe.testing:s3mock-testcontainers", version.ref = "s3mock" }
-testcontainers-juputer = { module = "org.testcontainers:junit-jupiter", version.ref = "testcontainers-jupiter" }
\ No newline at end of file
+testcontainers-juputer = { module = "org.testcontainers:junit-jupiter", version.ref = "testcontainers-jupiter" }
diff --git a/java/vortex-jni/build.gradle.kts b/java/vortex-jni/build.gradle.kts
index 3ffc0f8ef6c..bb652d0d86e 100644
--- a/java/vortex-jni/build.gradle.kts
+++ b/java/vortex-jni/build.gradle.kts
@@ -27,6 +27,7 @@ dependencies {
     implementation(libs.guava)
     compileOnly(libs.errorprone.annotations)
     compileOnly(libs.nopen.annotations)
+    api(libs.roaringbitmap)
 
     // Logging
     implementation(libs.slf4j.api)
@@ -48,7 +49,9 @@ mavenPublishing {
     coordinates(groupId = "dev.vortex", artifactId = "vortex-jni", version = "${rootProject.version}")
     publishToMavenCentral()
 
-    signAllPublications()
+    if (!project.hasProperty("skip.signing")) {
+        signAllPublications()
+    }
 
     pom {
         name = "vortex-jni"
@@ -131,18 +134,20 @@ tasks.register("makeTestFiles") {
 
         val osName = System.getProperty("os.name").lowercase()
         val osArch = System.getProperty("os.arch").lowercase()
-        val osShortName = when {
-            osName.contains("mac") -> "darwin"
-            osName.contains("nix") || osName.contains("nux") -> "linux"
-            osName.contains("win") -> "win"
-            else -> throw GradleException("Unsupported OS for makeTestFiles: $osName")
-        }
-        val libExt = when (osShortName) {
-            "darwin" -> ".dylib"
-            "linux" -> ".so"
-            "win" -> ".dll"
-            else -> throw GradleException("Unsupported OS short name: $osShortName")
-        }
+        val osShortName =
+            when {
+                osName.contains("mac") -> "darwin"
+                osName.contains("nix") || osName.contains("nux") -> "linux"
+                osName.contains("win") -> "win"
+                else -> throw GradleException("Unsupported OS for makeTestFiles: $osName")
+            }
+        val libExt =
+            when (osShortName) {
+                "darwin" -> ".dylib"
+                "linux" -> ".so"
+                "win" -> ".dll"
+                else -> throw GradleException("Unsupported OS short name: $osShortName")
+            }
 
         // Only populate the host-arch directory so cross-compiled libs for other
         // architectures (placed by the publish workflow) are preserved.
diff --git a/java/vortex-jni/src/main/java/dev/vortex/api/DataSource.java b/java/vortex-jni/src/main/java/dev/vortex/api/DataSource.java
index d13f7e6acc1..24780785274 100644
--- a/java/vortex-jni/src/main/java/dev/vortex/api/DataSource.java
+++ b/java/vortex-jni/src/main/java/dev/vortex/api/DataSource.java
@@ -136,13 +136,40 @@ public Scan scan(ScanOptions options) {
         long filterPtr = options.filter().map(Expression::nativePointer).orElse(0L);
         long begin = options.rowRangeBegin().orElse(0L);
         long end = options.rowRangeEnd().orElse(0L);
-        long[] selectionIndices = options.selectionIndices().orElse(null);
-        byte selectionMode = options.selectionMode().code();
+        ScanOptions.SelectionMode selectionMode = options.selectionMode();
+        long[] selectionIndices = selectionIndices(options);
+        byte[] selectionRoaringBitmap = selectionRoaringBitmap(options);
         long limit = options.limit().orElse(0L);
         boolean ordered = options.ordered();
 
         long scanPtr = dev.vortex.jni.NativeScan.create(
-                pointer, projectionPtr, filterPtr, begin, end, selectionIndices, selectionMode, limit, ordered);
+                pointer,
+                projectionPtr,
+                filterPtr,
+                begin,
+                end,
+                selectionIndices,
+                selectionRoaringBitmap,
+                selectionMode.code(),
+                limit,
+                ordered);
         return Scan.fromPointer(session, scanPtr);
     }
+
+    private static long[] selectionIndices(ScanOptions options) {
+        return switch (options.selectionMode()) {
+            case INCLUDE, EXCLUDE -> options.selectionIndices().orElse(null);
+            default -> null;
+        };
+    }
+
+    private static byte[] selectionRoaringBitmap(ScanOptions options) {
+        return switch (options.selectionMode()) {
+            case INCLUDE_ROARING, EXCLUDE_ROARING ->
+                options.selectionRoaringBitmap()
+                        .orElseThrow(() -> new IllegalArgumentException(
+                                "selection roaring bitmap is required for roaring selection modes"));
+            default -> null;
+        };
+    }
 }
diff --git a/java/vortex-jni/src/main/java/dev/vortex/api/Expression.java b/java/vortex-jni/src/main/java/dev/vortex/api/Expression.java
index 922c6ae3f07..b2e2a8be875 100644
--- a/java/vortex-jni/src/main/java/dev/vortex/api/Expression.java
+++ b/java/vortex-jni/src/main/java/dev/vortex/api/Expression.java
@@ -79,6 +79,30 @@ public static Expression select(String[] fieldNames, Expression child) {
         return new Expression(NativeExpression.select(fieldNames, child.nativePointer()));
     }
 
+    /** Creates an expression that packs values into a struct with named fields. */
+    public static Expression pack(String[] fieldNames, Expression[] expressions, boolean nullable) {
+        return new Expression(NativeExpression.pack(fieldNames, nativePointers(expressions), nullable));
+    }
+
+    /**
+     * Merge struct expressions into a single struct, combining their fields in order.
+     *
+     * <p>Every input must evaluate to a non-nullable struct. When the same field name appears in more than one input,
+     * {@code duplicateHandling} decides the result. Fields are <em>not</em> merged recursively — a later field replaces
+     * an earlier one with the same name. Merging zero expressions yields an empty struct.
+     */
+    public static Expression merge(DuplicateHandling duplicateHandling, Expression... expressions) {
+        return new Expression(NativeExpression.merge(nativePointers(expressions), duplicateHandling.tag()));
+    }
+
+    /**
+     * Merge struct expressions, failing if any field name is duplicated. Equivalent to {@link #merge(DuplicateHandling,
+     * Expression...)} with {@link DuplicateHandling#ERROR}.
+     */
+    public static Expression merge(Expression... expressions) {
+        return merge(DuplicateHandling.ERROR, expressions);
+    }
+
     /** Logical AND. Requires at least one operand. */
     public static Expression and(Expression... operands) {
         Preconditions.checkArgument(operands.length > 0, "and requires at least one operand");
@@ -287,6 +311,27 @@ public byte code() {
         }
     }
 
+    /**
+     * Strategy for resolving duplicate field names in {@link #merge(DuplicateHandling, Expression...)}. Tag values must
+     * match the Rust {@code parse_duplicate_handling} table.
+     */
+    public enum DuplicateHandling {
+        /** When two structs share a field name, keep the value from the right-most (later) struct. */
+        RIGHT_MOST((byte) 0),
+        /** When two structs share a field name, fail with an error. */
+        ERROR((byte) 1);
+
+        private final byte tag;
+
+        DuplicateHandling(byte tag) {
+            this.tag = tag;
+        }
+
+        public byte tag() {
+            return tag;
+        }
+    }
+
     /** Time units for Date/Timestamp literals. Tag values must match the Rust {@code parse_time_unit} table. */
     public enum TimeUnit {
         NANOSECONDS((byte) 0),
diff --git a/java/vortex-jni/src/main/java/dev/vortex/api/ScanOptions.java b/java/vortex-jni/src/main/java/dev/vortex/api/ScanOptions.java
index 2431f9e5722..e9009582e28 100644
--- a/java/vortex-jni/src/main/java/dev/vortex/api/ScanOptions.java
+++ b/java/vortex-jni/src/main/java/dev/vortex/api/ScanOptions.java
@@ -3,9 +3,15 @@
 
 package dev.vortex.api;
 
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.OptionalLong;
 import org.immutables.value.Value;
+import org.roaringbitmap.longlong.Roaring64NavigableMap;
 
 /**
  * Scan configuration passed to {@link DataSource#scan(ScanOptions)}.
@@ -28,12 +34,15 @@ public interface ScanOptions {
     OptionalLong rowRangeEnd();
 
     /**
-     * Sorted ascending row indices that should be included in (or excluded from) the scan, depending on
+     * Sorted ascending, unique row indices that should be included in (or excluded from) the scan, depending on
      * {@link #selectionMode()}.
      */
     Optional<long[]> selectionIndices();
 
-    /** Meaning of {@link #selectionIndices()}. */
+    /** Portable serialized {@link Roaring64NavigableMap} row selection. */
+    Optional<byte[]> selectionRoaringBitmap();
+
+    /** Meaning of the row selection payload. */
     @Value.Default
     default SelectionMode selectionMode() {
         return SelectionMode.INCLUDE_ALL;
@@ -48,6 +57,54 @@ default boolean ordered() {
         return false;
     }
 
+    @Value.Check
+    default void validateSelectionPayload() {
+        boolean hasIndices = selectionIndices().isPresent();
+        boolean hasRoaringBitmap = selectionRoaringBitmap().isPresent();
+        if (hasIndices && hasRoaringBitmap) {
+            throw new IllegalArgumentException("row selection must use either indices or roaring bitmap, not both");
+        }
+        if (hasIndices) {
+            validateSelectionIndices(selectionIndices().orElseThrow());
+        }
+
+        switch (selectionMode()) {
+            case INCLUDE_ALL -> {
+                if (hasIndices || hasRoaringBitmap) {
+                    throw new IllegalArgumentException("row selection payload requires a selection mode");
+                }
+            }
+            case INCLUDE, EXCLUDE -> {
+                if (!hasIndices) {
+                    throw new IllegalArgumentException("selection indices are required for index selection modes");
+                }
+            }
+            case INCLUDE_ROARING, EXCLUDE_ROARING -> {
+                if (!hasRoaringBitmap) {
+                    throw new IllegalArgumentException(
+                            "selection roaring bitmap is required for roaring selection modes");
+                }
+                if (selectionRoaringBitmap().orElseThrow().length == 0) {
+                    throw new IllegalArgumentException("selection roaring bitmap must not be empty");
+                }
+            }
+        }
+    }
+
+    private static void validateSelectionIndices(long[] selectionIndices) {
+        long previous = -1L;
+        for (int i = 0; i < selectionIndices.length; i++) {
+            long index = selectionIndices[i];
+            if (index < 0) {
+                throw new IllegalArgumentException("selection indices must be non-negative");
+            }
+            if (i > 0 && index <= previous) {
+                throw new IllegalArgumentException("selection indices must be sorted ascending and unique");
+            }
+            previous = index;
+        }
+    }
+
     static ScanOptions of() {
         return ImmutableScanOptions.builder().build();
     }
@@ -56,14 +113,62 @@ static ImmutableScanOptions.Builder builder() {
         return ImmutableScanOptions.builder();
     }
 
-    /** How to interpret {@link #selectionIndices()}. */
+    /** Scan only the rows at the given sorted ascending, unique row indices. */
+    static ScanOptions includeRows(long... rowIndices) {
+        return builder()
+                .selectionIndices(rowIndices.clone())
+                .selectionMode(SelectionMode.INCLUDE)
+                .build();
+    }
+
+    /** Scan all rows except the given sorted ascending, unique row indices. */
+    static ScanOptions excludeRows(long... rowIndices) {
+        return builder()
+                .selectionIndices(rowIndices.clone())
+                .selectionMode(SelectionMode.EXCLUDE)
+                .build();
+    }
+
+    /** Scan only the rows in the given Roaring bitmap. */
+    static ScanOptions includeRows(Roaring64NavigableMap rowSelection) {
+        return builder()
+                .selectionRoaringBitmap(serializeRoaringBitmap(rowSelection))
+                .selectionMode(SelectionMode.INCLUDE_ROARING)
+                .build();
+    }
+
+    /** Scan all rows except the rows in the given Roaring bitmap. */
+    static ScanOptions excludeRows(Roaring64NavigableMap rowSelection) {
+        return builder()
+                .selectionRoaringBitmap(serializeRoaringBitmap(rowSelection))
+                .selectionMode(SelectionMode.EXCLUDE_ROARING)
+                .build();
+    }
+
+    private static byte[] serializeRoaringBitmap(Roaring64NavigableMap rowSelection) {
+        Objects.requireNonNull(rowSelection, "rowSelection");
+        try (ByteArrayOutputStream output = new ByteArrayOutputStream();
+                DataOutputStream dataOutput = new DataOutputStream(output)) {
+            rowSelection.serializePortable(dataOutput);
+            dataOutput.flush();
+            return output.toByteArray();
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+    }
+
+    /** How to interpret the row selection payload. */
     enum SelectionMode {
-        /** Ignore {@link #selectionIndices()}. */
+        /** Ignore row selection payloads. */
         INCLUDE_ALL((byte) 0),
         /** Return only rows at the indices. */
         INCLUDE((byte) 1),
         /** Return rows except those at the indices. */
-        EXCLUDE((byte) 2);
+        EXCLUDE((byte) 2),
+        /** Return only rows in the Roaring bitmap. */
+        INCLUDE_ROARING((byte) 3),
+        /** Return rows except those in the Roaring bitmap. */
+        EXCLUDE_ROARING((byte) 4);
 
         private final byte code;
 
diff --git a/java/vortex-jni/src/main/java/dev/vortex/jni/NativeExpression.java b/java/vortex-jni/src/main/java/dev/vortex/jni/NativeExpression.java
index 068927bdc79..bcd82d4b313 100644
--- a/java/vortex-jni/src/main/java/dev/vortex/jni/NativeExpression.java
+++ b/java/vortex-jni/src/main/java/dev/vortex/jni/NativeExpression.java
@@ -19,6 +19,10 @@ private NativeExpression() {}
 
     public static native long select(String[] fieldNames, long childPointer);
 
+    public static native long pack(String[] fieldNames, long[] expressions, boolean nullable);
+
+    public static native long merge(long[] expressions, byte duplicateHandling);
+
     public static native long and(long[] operandPointers);
 
     public static native long or(long[] operandPointers);
diff --git a/java/vortex-jni/src/main/java/dev/vortex/jni/NativeScan.java b/java/vortex-jni/src/main/java/dev/vortex/jni/NativeScan.java
index fe1a2e7a674..86b4b2e3359 100644
--- a/java/vortex-jni/src/main/java/dev/vortex/jni/NativeScan.java
+++ b/java/vortex-jni/src/main/java/dev/vortex/jni/NativeScan.java
@@ -21,8 +21,10 @@ private NativeScan() {}
      * @param rowRangeBegin inclusive start of the row range, 0 for "unbounded"
      * @param rowRangeEnd exclusive end of the row range, 0 for "unbounded"
      * @param selectionIndices sorted row indices; may be null
+     * @param selectionRoaringBitmap portable serialized Roaring64 bitmap; may be null
      * @param selectionInclude {@code 0} (all), {@code 1} (include {@code selectionIndices}), {@code 2} (exclude
-     *     {@code selectionIndices})
+     *     {@code selectionIndices}), {@code 3} (include {@code selectionRoaringBitmap}), {@code 4} (exclude
+     *     {@code selectionRoaringBitmap})
      * @param limit max rows to return, or {@code 0} for "no limit"
      * @param ordered true to preserve row order across partitions
      */
@@ -33,6 +35,7 @@ public static native long create(
             long rowRangeBegin,
             long rowRangeEnd,
             long[] selectionIndices,
+            byte[] selectionRoaringBitmap,
             byte selectionInclude,
             long limit,
             boolean ordered);
diff --git a/java/vortex-jni/src/test/java/dev/vortex/api/ExpressionTest.java b/java/vortex-jni/src/test/java/dev/vortex/api/ExpressionTest.java
index f171267253b..e02024311d8 100644
--- a/java/vortex-jni/src/test/java/dev/vortex/api/ExpressionTest.java
+++ b/java/vortex-jni/src/test/java/dev/vortex/api/ExpressionTest.java
@@ -22,7 +22,8 @@ public static void loadLibrary() {
     @Test
     public void rowIdxBuildsAndComposes() {
         assertNotNull(Expression.rowIdx());
-        // Mirrors `gt(row_idx(), lit(...))` on the Rust side: the row-index expression composes like any other.
+        // Mirrors `gt(row_idx(), lit(...))` on the Rust side: the row-index expression
+        // composes like any other.
         assertNotNull(Expression.binary(Expression.BinaryOp.LT, Expression.rowIdx(), Expression.literal(5L)));
     }
 
@@ -35,4 +36,23 @@ public void literalDecimalRejectsValuesLargerThan32Bytes() {
                 assertThrows(RuntimeException.class, () -> Expression.literalDecimal(tooLarge, 76, 0));
         assertTrue(exception.getMessage().contains("Decimal value must fit with 32 bytes"));
     }
+
+    @Test
+    public void packComposes() {
+        assertNotNull(Expression.pack(
+                new String[] {"x", "y", "z"},
+                new Expression[] {Expression.column("a"), Expression.literal(5L), Expression.rowIdx()},
+                true));
+    }
+
+    @Test
+    public void mergeComposes() {
+        // Default duplicate handling (ERROR).
+        assertNotNull(Expression.merge(Expression.column("a"), Expression.column("b")));
+        // Explicit duplicate handling.
+        assertNotNull(Expression.merge(
+                Expression.DuplicateHandling.RIGHT_MOST, Expression.column("a"), Expression.column("b")));
+        // Merging zero expressions is valid and yields an empty struct.
+        assertNotNull(Expression.merge());
+    }
 }
diff --git a/java/vortex-jni/src/test/java/dev/vortex/api/TestMinimal.java b/java/vortex-jni/src/test/java/dev/vortex/api/TestMinimal.java
index b422b767dd3..322dc5522c3 100644
--- a/java/vortex-jni/src/test/java/dev/vortex/api/TestMinimal.java
+++ b/java/vortex-jni/src/test/java/dev/vortex/api/TestMinimal.java
@@ -5,6 +5,7 @@
 
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import dev.vortex.arrow.ArrowAllocation;
 import dev.vortex.jni.NativeLoader;
@@ -31,6 +32,7 @@
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
+import org.roaringbitmap.longlong.Roaring64NavigableMap;
 
 public final class TestMinimal {
     static final class Person {
@@ -180,6 +182,73 @@ public void testProjectedScanWithFilter() throws Exception {
         assertEquals(List.of(new Person("John", BigDecimal.valueOf(10_000L, 2), "VA")), people);
     }
 
+    @Test
+    public void testSelectionIncludesRows() throws Exception {
+        BufferAllocator allocator = ArrowAllocation.rootAllocator();
+        Session session = Session.create();
+        DataSource ds = DataSource.open(session, writePath);
+
+        List<Person> people = readAll(ds, ScanOptions.includeRows(0, 3, 9), allocator, TestMinimal::readFullBatch);
+        assertEquals(List.of(MINIMAL_DATA.get(0), MINIMAL_DATA.get(3), MINIMAL_DATA.get(9)), people);
+    }
+
+    @Test
+    public void testSelectionExcludesRows() throws Exception {
+        BufferAllocator allocator = ArrowAllocation.rootAllocator();
+        Session session = Session.create();
+        DataSource ds = DataSource.open(session, writePath);
+
+        List<Person> people = readAll(ds, ScanOptions.excludeRows(0, 9), allocator, TestMinimal::readFullBatch);
+        assertEquals(MINIMAL_DATA.subList(1, 9), people);
+    }
+
+    @Test
+    public void testRoaringSelectionIncludesRows() throws Exception {
+        BufferAllocator allocator = ArrowAllocation.rootAllocator();
+        Session session = Session.create();
+        DataSource ds = DataSource.open(session, writePath);
+
+        List<Person> people =
+                readAll(ds, ScanOptions.includeRows(roaringRows(0, 3, 9)), allocator, TestMinimal::readFullBatch);
+        assertEquals(List.of(MINIMAL_DATA.get(0), MINIMAL_DATA.get(3), MINIMAL_DATA.get(9)), people);
+    }
+
+    @Test
+    public void testRoaringSelectionExcludesRows() throws Exception {
+        BufferAllocator allocator = ArrowAllocation.rootAllocator();
+        Session session = Session.create();
+        DataSource ds = DataSource.open(session, writePath);
+
+        List<Person> people =
+                readAll(ds, ScanOptions.excludeRows(roaringRows(0, 9)), allocator, TestMinimal::readFullBatch);
+        assertEquals(MINIMAL_DATA.subList(1, 9), people);
+    }
+
+    @Test
+    public void testSelectionIndicesMustBeSortedAndUnique() {
+        IllegalArgumentException exception =
+                assertThrows(IllegalArgumentException.class, () -> ScanOptions.includeRows(2, 1));
+        assertEquals("selection indices must be sorted ascending and unique", exception.getMessage());
+    }
+
+    @Test
+    public void testSelectionPayloadMustChooseIndicesOrRoaring() {
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> ScanOptions.builder()
+                .selectionMode(ScanOptions.SelectionMode.INCLUDE)
+                .selectionIndices(new long[] {0})
+                .selectionRoaringBitmap(new byte[] {1})
+                .build());
+        assertEquals("row selection must use either indices or roaring bitmap, not both", exception.getMessage());
+    }
+
+    @Test
+    public void testSelectionPayloadRequiresMode() {
+        IllegalArgumentException exception = assertThrows(
+                IllegalArgumentException.class,
+                () -> ScanOptions.builder().selectionIndices(new long[] {0}).build());
+        assertEquals("row selection payload requires a selection mode", exception.getMessage());
+    }
+
     private interface BatchReader {
         List<Person> read(VectorSchemaRoot root);
     }
@@ -221,4 +290,12 @@ private static List<Person> readFullBatch(VectorSchemaRoot root) {
         }
         return result;
     }
+
+    private static Roaring64NavigableMap roaringRows(long... rows) {
+        Roaring64NavigableMap bitmap = new Roaring64NavigableMap();
+        for (long row : rows) {
+            bitmap.addLong(row);
+        }
+        return bitmap;
+    }
 }
diff --git a/java/vortex-jni/src/test/java/dev/vortex/jni/JNIWriterTest.java b/java/vortex-jni/src/test/java/dev/vortex/jni/JNIWriterTest.java
index 58cdbbf5315..03869ae8598 100644
--- a/java/vortex-jni/src/test/java/dev/vortex/jni/JNIWriterTest.java
+++ b/java/vortex-jni/src/test/java/dev/vortex/jni/JNIWriterTest.java
@@ -4,6 +4,7 @@
 package dev.vortex.jni;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -26,17 +27,25 @@
 import org.apache.arrow.c.Data;
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.vector.IntVector;
+import org.apache.arrow.vector.VarBinaryVector;
 import org.apache.arrow.vector.VarCharVector;
 import org.apache.arrow.vector.VectorSchemaRoot;
+import org.apache.arrow.vector.complex.StructVector;
 import org.apache.arrow.vector.ipc.ArrowReader;
 import org.apache.arrow.vector.types.pojo.ArrowType;
 import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.arrow.vector.types.pojo.FieldType;
 import org.apache.arrow.vector.types.pojo.Schema;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
 
 public final class JNIWriterTest {
+    private static final String ARROW_EXTENSION_NAME = "ARROW:extension:name";
+    private static final String PARQUET_VARIANT_EXTENSION_NAME = "arrow.parquet.variant";
+    private static final byte[] VARIANT_METADATA = new byte[] {0x01, 0x00};
+    private static final byte[] VARIANT_INT8_42 = new byte[] {0x0c, 0x2a};
+    private static final byte[] VARIANT_TRUE = new byte[] {0x04};
 
     @TempDir
     Path tempDir;
@@ -52,6 +61,45 @@ private static Schema personSchema() {
                 Field.notNullable("age", new ArrowType.Int(32, true))));
     }
 
+    private static Schema parquetVariantSchema() {
+        Field variant = new Field(
+                "variant",
+                new FieldType(
+                        true,
+                        ArrowType.Struct.INSTANCE,
+                        null,
+                        Map.of(ARROW_EXTENSION_NAME, PARQUET_VARIANT_EXTENSION_NAME)),
+                List.of(
+                        Field.notNullable("metadata", new ArrowType.Binary()),
+                        Field.nullable("value", new ArrowType.Binary())));
+        return new Schema(List.of(variant));
+    }
+
+    private static void populateParquetVariantRoot(VectorSchemaRoot root) {
+        StructVector variant = (StructVector) root.getVector("variant");
+        VarBinaryVector metadata = variant.getChild("metadata", VarBinaryVector.class);
+        VarBinaryVector value = variant.getChild("value", VarBinaryVector.class);
+
+        variant.allocateNew();
+        metadata.allocateNew(3);
+        value.allocateNew(3);
+
+        metadata.setSafe(0, VARIANT_METADATA);
+        metadata.setSafe(1, VARIANT_METADATA);
+        metadata.setSafe(2, VARIANT_METADATA);
+        value.setSafe(0, VARIANT_INT8_42);
+        value.setSafe(1, VARIANT_TRUE);
+        value.setNull(2);
+        variant.setIndexDefined(0);
+        variant.setIndexDefined(1);
+        variant.setNull(2);
+
+        metadata.setValueCount(3);
+        value.setValueCount(3);
+        variant.setValueCount(3);
+        root.setRowCount(3);
+    }
+
     @Test
     public void testCreateWriter() throws IOException {
         Path outputPath = tempDir.resolve("test_create.vortex");
@@ -155,4 +203,53 @@ public void testWriteBatch() throws IOException {
             }
         }
     }
+
+    @Test
+    public void testParquetVariantRoundTrip() throws IOException {
+        Path outputPath = tempDir.resolve("test_parquet_variant.vortex");
+        String writePath = outputPath.toAbsolutePath().toUri().toString();
+
+        BufferAllocator allocator = ArrowAllocation.rootAllocator();
+        Schema schema = parquetVariantSchema();
+
+        Session session = Session.create();
+        try (VortexWriter writer = VortexWriter.create(session, writePath, schema, new HashMap<>(), allocator);
+                VectorSchemaRoot root = VectorSchemaRoot.create(schema, allocator)) {
+            populateParquetVariantRoot(root);
+
+            try (ArrowArray arrowArray = ArrowArray.allocateNew(allocator);
+                    ArrowSchema arrowSchemaFfi = ArrowSchema.allocateNew(allocator)) {
+                Data.exportVectorSchemaRoot(allocator, root, null, arrowArray, arrowSchemaFfi);
+                writer.writeBatch(arrowArray.memoryAddress(), arrowSchemaFfi.memoryAddress());
+            }
+        }
+
+        assertTrue(Files.exists(outputPath), "output file should exist");
+
+        DataSource ds = DataSource.open(session, writePath);
+        Field dataSourceField = ds.arrowSchema(allocator).findField("variant");
+        assertEquals(
+                PARQUET_VARIANT_EXTENSION_NAME, dataSourceField.getMetadata().get(ARROW_EXTENSION_NAME));
+
+        Scan scan = ds.scan(ScanOptions.of());
+        Field scanField = scan.arrowSchema(allocator).findField("variant");
+        assertEquals(PARQUET_VARIANT_EXTENSION_NAME, scanField.getMetadata().get(ARROW_EXTENSION_NAME));
+
+        while (scan.hasNext()) {
+            Partition p = scan.next();
+            try (ArrowReader reader = p.scanArrow(allocator)) {
+                assertTrue(reader.loadNextBatch());
+                VectorSchemaRoot resultRoot = reader.getVectorSchemaRoot();
+                StructVector variant = (StructVector) resultRoot.getVector("variant");
+                VarBinaryVector metadata = variant.getChild("metadata", VarBinaryVector.class);
+                VarBinaryVector value = variant.getChild("value", VarBinaryVector.class);
+
+                assertArrayEquals(VARIANT_METADATA, metadata.get(0));
+                assertArrayEquals(VARIANT_INT8_42, value.get(0));
+                assertArrayEquals(VARIANT_METADATA, metadata.get(1));
+                assertArrayEquals(VARIANT_TRUE, value.get(1));
+                assertTrue(variant.isNull(2));
+            }
+        }
+    }
 }
diff --git a/java/vortex-spark/build.gradle.kts b/java/vortex-spark/build.gradle.kts
index 97527a07ffe..9dc46f4c6d9 100644
--- a/java/vortex-spark/build.gradle.kts
+++ b/java/vortex-spark/build.gradle.kts
@@ -70,7 +70,9 @@ mavenPublishing {
 
     publishToMavenCentral()
 
-    signAllPublications()
+    if (!project.hasProperty("skip.signing")) {
+        signAllPublications()
+    }
 
     pom {
         name = "vortex-spark_$scalaVersion"
diff --git a/java/vortex-spark/src/main/java/dev/vortex/spark/read/SparkPredicateToVortexExpression.java b/java/vortex-spark/src/main/java/dev/vortex/spark/read/SparkPredicateToVortexExpression.java
index 8d3fe697153..781c008c79a 100644
--- a/java/vortex-spark/src/main/java/dev/vortex/spark/read/SparkPredicateToVortexExpression.java
+++ b/java/vortex-spark/src/main/java/dev/vortex/spark/read/SparkPredicateToVortexExpression.java
@@ -6,6 +6,13 @@
 import dev.vortex.api.Expression;
 import dev.vortex.api.Expression.BinaryOp;
 import dev.vortex.api.Expression.TimeUnit;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 import org.apache.spark.sql.connector.expressions.filter.AlwaysFalse;
@@ -33,14 +40,6 @@
 import org.apache.spark.sql.types.TimestampType;
 import org.apache.spark.unsafe.types.UTF8String;
 
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-
 /**
  * Translates {@link Predicate Spark V2 predicates} into Vortex {@link Expression}s for predicate pushdown.
  *
@@ -50,16 +49,15 @@
  */
 final class SparkPredicateToVortexExpression {
 
-    private SparkPredicateToVortexExpression() {
-    }
+    private SparkPredicateToVortexExpression() {}
 
     /**
      * Returns true if the given Spark predicate can be translated to a Vortex expression and every named reference
      * resolves to a real field path under {@code dataColumnTypes}.
      *
      * <p>{@code dataColumnTypes} maps each pushable top-level column name to its top-level Spark {@link DataType};
-     * partition columns and columns the scan does not project should not appear in the map. For nested references
-     * (for example {@code info.email}) the validator walks the named reference part by part, descending into
+     * partition columns and columns the scan does not project should not appear in the map. For nested references (for
+     * example {@code info.email}) the validator walks the named reference part by part, descending into
      * {@link StructType} fields so that {@code info} must be a struct that contains an {@code email} field.
      *
      * <p>This is the cheap check used in {@code SupportsPushDownV2Filters.pushPredicates} to decide which predicates
@@ -77,8 +75,7 @@ static boolean isPushable(Predicate predicate, Map<String, DataType> dataColumnT
 
     /**
      * Walks {@code parts} against {@code dataColumnTypes}, descending through {@link StructType} fields for
-     * dot-separated nested references. Returns true only when every part resolves to an actual field in the
-     * schema.
+     * dot-separated nested references. Returns true only when every part resolves to an actual field in the schema.
      */
     private static boolean resolveFieldPath(String[] parts, Map<String, DataType> dataColumnTypes) {
         if (parts.length == 0) {
@@ -102,7 +99,9 @@ private static boolean resolveFieldPath(String[] parts, Map<String, DataType> da
     }
 
     private static Optional<StructField> findField(StructType struct, String name) {
-        return Arrays.stream(struct.fields()).filter(structField -> structField.name().equals(name)).findFirst();
+        return Arrays.stream(struct.fields())
+                .filter(structField -> structField.name().equals(name))
+                .findFirst();
     }
 
     private static boolean isStructurallyPushable(Predicate predicate) {
@@ -135,7 +134,7 @@ private static boolean isStructurallyPushable(Predicate predicate) {
                 yield true;
             }
             case "STARTS_WITH", "ENDS_WITH", "CONTAINS" ->
-                    children.length == 2 && isPushableFieldRef(children[0]) && isPushableStringLiteral(children[1]);
+                children.length == 2 && isPushableFieldRef(children[0]) && isPushableStringLiteral(children[1]);
             // `BOOLEAN_EXPRESSION` wraps a bare boolean-valued child. We only handle the case
             // where the child itself is a field reference (e.g. `WHERE bool_col`).
             case "BOOLEAN_EXPRESSION" -> children.length == 1 && isPushableFieldRef(children[0]);
@@ -178,12 +177,12 @@ static Optional<Expression> convert(Predicate predicate) {
             case "=", "<>", "!=", ">", ">=", "<", "<=" -> convertComparison(predicate.name(), children);
             case "IS_NULL" -> children.length == 1 ? columnOf(children[0]).map(Expression::isNull) : Optional.empty();
             case "IS_NOT_NULL" ->
-                    children.length == 1 ? columnOf(children[0]).map(Expression::isNotNull) : Optional.empty();
+                children.length == 1 ? columnOf(children[0]).map(Expression::isNotNull) : Optional.empty();
             case "IN" -> convertIn(children);
             case "STARTS_WITH" ->
-                    convertStringMatch(children, /* leadingWildcard= */ false, /* trailingWildcard= */ true);
+                convertStringMatch(children, /* leadingWildcard= */ false, /* trailingWildcard= */ true);
             case "ENDS_WITH" ->
-                    convertStringMatch(children, /* leadingWildcard= */ true, /* trailingWildcard= */ false);
+                convertStringMatch(children, /* leadingWildcard= */ true, /* trailingWildcard= */ false);
             case "CONTAINS" -> convertStringMatch(children, /* leadingWildcard= */ true, /* trailingWildcard= */ true);
             case "BOOLEAN_EXPRESSION" -> children.length == 1 ? columnOf(children[0]) : Optional.empty();
             default -> Optional.empty();
@@ -327,9 +326,7 @@ private static boolean isFieldRefExpr(org.apache.spark.sql.connector.expressions
         return expr instanceof NamedReference;
     }
 
-    /**
-     * Returns the Vortex column expression for a Spark named reference, walking nested struct fields.
-     */
+    /** Returns the Vortex column expression for a Spark named reference, walking nested struct fields. */
     private static Optional<Expression> columnOf(org.apache.spark.sql.connector.expressions.Expression expr) {
         if (!(expr instanceof NamedReference)) {
             return Optional.empty();
@@ -501,9 +498,7 @@ private static Optional<Expression> convertLiteral(Object value, DataType dataTy
         return Optional.empty();
     }
 
-    /**
-     * Extract the unscaled integer value of a Spark decimal literal at the supplied {@code scale}.
-     */
+    /** Extract the unscaled integer value of a Spark decimal literal at the supplied {@code scale}. */
     private static BigInteger unscaledValueOf(Object value, int scale) {
         BigDecimal decimal;
         if (value instanceof Decimal) {
diff --git a/scripts/compare-benchmark-jsons.py b/scripts/compare-benchmark-jsons.py
index 69009a5494a..7d560c144a3 100644
--- a/scripts/compare-benchmark-jsons.py
+++ b/scripts/compare-benchmark-jsons.py
@@ -4,6 +4,7 @@
 #   "numpy",
 #   "pandas",
 #   "tabulate",
+#   "orjson"
 # ]
 # ///
 
@@ -18,6 +19,7 @@
 from typing import Any
 
 import numpy as np
+import orjson
 import pandas as pd
 
 # Analysis overview:
@@ -59,9 +61,7 @@ def extract_dataset_key(df: pd.DataFrame) -> pd.DataFrame:
     if "dataset" not in df.columns:
         df["dataset_key"] = pd.NA
     else:
-        df["dataset_key"] = df["dataset"].apply(
-            lambda x: str(sorted(x.items())) if pd.notna(x) and isinstance(x, dict) else pd.NA
-        )
+        df["dataset_key"] = df["dataset"].apply(dataset_key)
     return df
 
 
@@ -77,6 +77,126 @@ def split_file_size_rows(df: pd.DataFrame) -> tuple[pd.DataFrame, pd.DataFrame]:
     return df[mask].copy(), df[~mask].copy()
 
 
+def identity_value(value: Any) -> Any:
+    """Normalize missing values so benchmark identities compare reliably."""
+
+    return None if pd.isna(value) else value
+
+
+def dataset_key(value: Any) -> str | None:
+    """Normalize dataset metadata into the join-key representation."""
+
+    if isinstance(value, dict):
+        return str(sorted(value.items()))
+    return None
+
+
+def benchmark_identity(row: Any) -> tuple[Any, Any, Any] | None:
+    """Return the timing-row identity used to find a matching baseline."""
+
+    if row.get("metric") == FILE_SIZE_METRIC or row.get("file_size") is not None:
+        return None
+
+    name = row.get("name")
+    if name is None:
+        return None
+
+    return (
+        identity_value(name),
+        identity_value(row.get("storage")),
+        dataset_key(row.get("dataset")),
+    )
+
+
+def benchmark_identity_rows(df: pd.DataFrame) -> pd.DataFrame:
+    """Return timing rows with the identity used to match a PR benchmark."""
+
+    _file_size_rows, timing_rows = split_file_size_rows(df)
+    if timing_rows.empty or "name" not in timing_rows.columns:
+        return pd.DataFrame(columns=["commit_id", "benchmark_identity"])
+
+    timing_rows = timing_rows.copy()
+    if "storage" not in timing_rows.columns:
+        timing_rows["storage"] = pd.NA
+    if "commit_id" not in timing_rows.columns:
+        timing_rows["commit_id"] = pd.NA
+
+    timing_rows = extract_dataset_key(timing_rows)
+    timing_rows["benchmark_identity"] = [
+        tuple(identity_value(row[column]) for column in ("name", "storage", "dataset_key"))
+        for _, row in timing_rows.iterrows()
+    ]
+
+    return timing_rows[["commit_id", "benchmark_identity"]]
+
+
+def read_jsonl_rows_for_commit(path: str, commit_id: str) -> pd.DataFrame:
+    """Read only rows matching a commit from a JSONL benchmark history."""
+
+    rows = []
+    with open(path, encoding="utf-8") as lines:
+        for line in lines:
+            if '"commit_id"' not in line or f'"{commit_id}"' not in line:
+                continue
+            record = orjson.loads(line)
+            if record.get("commit_id") == commit_id:
+                rows.append(record)
+    return pd.DataFrame(rows)
+
+
+def read_latest_baseline_rows(path: str, pr: pd.DataFrame) -> pd.DataFrame:
+    """Read rows from the latest history commit matching the PR benchmark."""
+
+    pr_identities = set(benchmark_identity_rows(pr)["benchmark_identity"])
+    if not pr_identities:
+        return pd.read_json(path, lines=True)
+
+    baseline_commit_id = None
+    with open(path, encoding="utf-8") as lines:
+        for line in lines:
+            if '"name"' not in line or '"commit_id"' not in line:
+                continue
+            record = orjson.loads(line)
+            if benchmark_identity(record) in pr_identities:
+                commit_id = record.get("commit_id")
+                if commit_id is not None:
+                    baseline_commit_id = commit_id
+
+    if baseline_commit_id is None:
+        raise ValueError("No baseline rows found for the benchmark under test")
+
+    return read_jsonl_rows_for_commit(path, baseline_commit_id)
+
+
+def select_latest_baseline_rows(base: pd.DataFrame, pr: pd.DataFrame) -> pd.DataFrame:
+    """Select rows from the latest baseline commit containing this benchmark.
+
+    The persisted benchmark history is append-only. A row only appears after
+    that benchmark job uploaded results, so the newest commit with matching row
+    identities is the latest successful baseline for the benchmark under test.
+    """
+
+    if base.empty or "commit_id" not in base.columns:
+        return base
+
+    commit_ids = base["commit_id"].dropna().unique()
+    if len(commit_ids) <= 1:
+        return base
+
+    pr_identities = set(benchmark_identity_rows(pr)["benchmark_identity"])
+    if not pr_identities:
+        return base
+
+    base_identities = benchmark_identity_rows(base)
+    matches = base_identities[base_identities["benchmark_identity"].isin(pr_identities)]
+    matches = matches[matches["commit_id"].notna()]
+    if matches.empty:
+        raise ValueError("No baseline rows found for the benchmark under test")
+
+    baseline_commit_id = matches["commit_id"].iloc[-1]
+    return base[base["commit_id"] == baseline_commit_id].copy()
+
+
 def extract_target_fields(name: str) -> pd.Series:
     """Parse query, engine, and format from the benchmark name."""
 
@@ -702,8 +822,8 @@ def main() -> None:
 
     benchmark_name = sys.argv[3] if len(sys.argv) > 3 else ""
 
-    base = pd.read_json(sys.argv[1], lines=True)
     pr = pd.read_json(sys.argv[2], lines=True)
+    base = read_latest_baseline_rows(sys.argv[1], pr)
 
     base_commit_id = set(base["commit_id"].unique())
     pr_commit_id = set(pr["commit_id"].unique())
@@ -783,22 +903,6 @@ def main() -> None:
     print("---")
     print("")
 
-    if statistical_analysis is not None:
-        alpha_rows = statistical_analysis["detail_df"][~statistical_analysis["detail_df"]["is_control"]].copy()
-        if not alpha_rows.empty:
-            alpha_rows = alpha_rows.sort_values(["query", "engine", "file_format"])
-            alpha_table = pd.DataFrame(
-                {
-                    "Query": alpha_rows["query"].astype(int),
-                    "Config": alpha_rows["combo"],
-                    "Raw Δ": alpha_rows["ratio"].map(format_ratio_change),
-                    "Control Δ": alpha_rows["beta_ratio"].map(format_ratio_change),
-                    "Attributed α": alpha_rows["alpha_ratio"].map(format_ratio_change),
-                    "Noise floor": alpha_rows["noise_floor_ratio"].map(format_ratio_change),
-                    "Significant?": alpha_rows["signal"].map(format_signal),
-                }
-            )
-
     grouped_tables = df3.groupby(["engine", "file_format"], dropna=False, sort=False)
     for engine, file_format in sorted(grouped_tables.groups.keys(), key=group_sort_key):
         group_df = grouped_tables.get_group((engine, file_format)).sort_values("name")
@@ -847,21 +951,6 @@ def main() -> None:
         print("")
         print(file_size_report)
 
-    if statistical_analysis is not None and not alpha_rows.empty:
-        print("<details>")
-        print("<summary>Full attributed analysis</summary>")
-        print("")
-        print("<br>")
-        print("")
-        print(
-            alpha_table.to_markdown(
-                index=False,
-                tablefmt="github",
-            )
-        )
-        print("")
-        print("</details>")
-
 
 if __name__ == "__main__":
     main()
diff --git a/scripts/tests/test_benchmark_reporting.py b/scripts/tests/test_benchmark_reporting.py
index ac356eff130..7925161e91e 100644
--- a/scripts/tests/test_benchmark_reporting.py
+++ b/scripts/tests/test_benchmark_reporting.py
@@ -33,6 +33,112 @@ def timing_row(name: str, base: int, pr: int) -> dict[str, object]:
     }
 
 
+def stored_timing_row(
+    commit: str,
+    name: str,
+    value: int,
+    storage: str | None = None,
+    dataset: dict[str, object] | None = None,
+) -> dict[str, object]:
+    row: dict[str, object] = {
+        "name": name,
+        "unit": "ns",
+        "value": value,
+        "all_runtimes": [value, value, value],
+        "commit_id": commit,
+    }
+    if storage is not None:
+        row["storage"] = storage
+    if dataset is not None:
+        row["dataset"] = dataset
+    return row
+
+
+def test_select_latest_baseline_rows_uses_latest_matching_benchmark_commit() -> None:
+    compare = load_compare_module()
+    history = pd.DataFrame(
+        [
+            stored_timing_row(
+                "base-old",
+                "tpch_q01/datafusion:parquet",
+                100,
+                "nvme",
+                {"scale_factor": "1.0"},
+            ),
+            file_size_record_for("base-old", 100, "tpch", "1.0", "vortex-file-compressed", "part-0.vortex"),
+            stored_timing_row(
+                "base-current",
+                "tpch_q01/datafusion:parquet",
+                110,
+                "nvme",
+                {"scale_factor": "1.0"},
+            ),
+            file_size_record_for("base-current", 120, "tpch", "1.0", "vortex-file-compressed", "part-0.vortex"),
+            stored_timing_row("base-other", "clickbench_q01/datafusion:parquet", 200, "nvme"),
+        ]
+    )
+    pr = pd.DataFrame(
+        [
+            stored_timing_row(
+                "pr-sha",
+                "tpch_q01/datafusion:parquet",
+                115,
+                "nvme",
+                {"scale_factor": "1.0"},
+            ),
+        ]
+    )
+
+    selected = compare.select_latest_baseline_rows(history, pr)
+
+    assert set(selected["commit_id"]) == {"base-current"}
+    assert len(selected) == 2
+
+
+def test_read_latest_baseline_rows_streams_latest_matching_benchmark_commit(tmp_path: Path) -> None:
+    compare = load_compare_module()
+    history_path = tmp_path / "history.jsonl"
+    history_rows = [
+        stored_timing_row(
+            "base-old",
+            "tpch_q01/datafusion:parquet",
+            100,
+            "nvme",
+            {"scale_factor": "1.0"},
+        ),
+        file_size_record_for("base-old", 100, "tpch", "1.0", "vortex-file-compressed", "part-0.vortex"),
+        stored_timing_row(
+            "base-current",
+            "tpch_q01/datafusion:parquet",
+            110,
+            "nvme",
+            {"scale_factor": "1.0"},
+        ),
+        file_size_record_for("base-current", 120, "tpch", "1.0", "vortex-file-compressed", "part-0.vortex"),
+        stored_timing_row("base-other", "clickbench_q01/datafusion:parquet", 200, "nvme"),
+    ]
+    history_path.write_text(
+        "".join(f"{json.dumps(row)}\n" for row in history_rows),
+        encoding="utf-8",
+    )
+    pr = pd.DataFrame(
+        [
+            stored_timing_row(
+                "pr-sha",
+                "tpch_q01/datafusion:parquet",
+                115,
+                "nvme",
+                {"scale_factor": "1.0"},
+            ),
+        ]
+    )
+
+    selected = compare.read_latest_baseline_rows(history_path, pr)
+
+    assert set(selected["commit_id"]) == {"base-current"}
+    assert len(selected) == 2
+
+
 def test_within_engine_analysis_uses_each_engines_own_parquet_control() -> None:
     compare = load_compare_module()
     rows = [
diff --git a/uv.lock b/uv.lock
index be0882bdf37..ef6e5670aaf 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1761,15 +1761,15 @@ wheels = [
 
 [[package]]
 name = "starlette"
-version = "0.52.1"
+version = "1.2.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
     { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c4/68/79977123bb7be889ad680d79a40f339082c1978b5cfcf62c2d8d196873ac/starlette-0.52.1.tar.gz", hash = "sha256:834edd1b0a23167694292e94f597773bc3f89f362be6effee198165a35d62933", size = 2653702, upload-time = "2026-01-18T13:34:11.062Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/25/44/ec35f1b6e83094b997da438a02c8c9b0ade2b1e84cfc48bd4656780760a6/starlette-1.2.1.tar.gz", hash = "sha256:9b9b5ebb992e67d6093741e63c2f59e4f6fff986f81163c087867bd7b924b3f6", size = 2701854, upload-time = "2026-05-31T01:07:51.847Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/81/0d/13d1d239a25cbfb19e740db83143e95c772a1fe10202dda4b76792b114dd/starlette-0.52.1-py3-none-any.whl", hash = "sha256:0029d43eb3d273bc4f83a08720b4912ea4b071087a3b48db01b7c839f7954d74", size = 74272, upload-time = "2026-01-18T13:34:09.188Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/54/196d0c1db10af76baa4f64894448505d60d3cdf70ef92cbb35f46a4e4c71/starlette-1.2.1-py3-none-any.whl", hash = "sha256:4de0082d08c8f6764a85a54cf1120d6939507a19905c7768acad2a9f875d2b89", size = 73350, upload-time = "2026-05-31T01:07:50.09Z" },
 ]
 
 [[package]]
diff --git a/vortex-array/Cargo.toml b/vortex-array/Cargo.toml
index e103097f8b6..4ec8a83575e 100644
--- a/vortex-array/Cargo.toml
+++ b/vortex-array/Cargo.toml
@@ -45,7 +45,6 @@ humansize = { workspace = true }
 inventory = { workspace = true }
 itertools = { workspace = true }
 jiff = { workspace = true }
-multiversion = { workspace = true }
 num-traits = { workspace = true }
 num_enum = { workspace = true }
 parking_lot = { workspace = true }
@@ -95,6 +94,7 @@ rand_distr = { workspace = true }
 rstest = { workspace = true }
 serde_json = { workspace = true }
 serde_test = { workspace = true }
+test-with = { workspace = true }
 vortex-array = { path = ".", features = ["_test-harness", "table-display"] }
 
 [[bench]]
@@ -105,6 +105,10 @@ harness = false
 name = "aggregate_sum"
 harness = false
 
+[[bench]]
+name = "aggregate_grouped"
+harness = false
+
 [[bench]]
 name = "cast_primitive"
 harness = false
@@ -121,6 +125,10 @@ harness = false
 name = "compare"
 harness = false
 
+[[bench]]
+name = "interleave"
+harness = false
+
 [[bench]]
 name = "take_patches"
 harness = false
@@ -187,6 +195,14 @@ harness = false
 name = "varbinview_zip"
 harness = false
 
+[[bench]]
+name = "bool_zip"
+harness = false
+
+[[bench]]
+name = "primitive_zip"
+harness = false
+
 [[bench]]
 name = "take_primitive"
 harness = false
diff --git a/vortex-array/benches/aggregate_grouped.rs b/vortex-array/benches/aggregate_grouped.rs
new file mode 100644
index 00000000000..b067314c1d9
--- /dev/null
+++ b/vortex-array/benches/aggregate_grouped.rs
@@ -0,0 +1,207 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![expect(clippy::cast_possible_truncation)]
+#![expect(clippy::unwrap_used)]
+
+use divan::Bencher;
+use rand::RngExt;
+use rand::SeedableRng;
+use rand::rngs::StdRng;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::LEGACY_SESSION;
+use vortex_array::VortexSessionExecute;
+use vortex_array::aggregate_fn::AggregateFnVTable;
+use vortex_array::aggregate_fn::DynGroupedAccumulator;
+use vortex_array::aggregate_fn::EmptyOptions;
+use vortex_array::aggregate_fn::GroupedAccumulator;
+use vortex_array::aggregate_fn::fns::count::Count;
+use vortex_array::aggregate_fn::fns::sum::Sum;
+use vortex_array::arrays::ListViewArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::VarBinViewArray;
+use vortex_array::dtype::DType;
+use vortex_array::validity::Validity;
+use vortex_buffer::Buffer;
+
+fn main() {
+    divan::main();
+}
+
+const GROUP_COUNT: usize = 128;
+const GROUP_SIZE_SEED: u64 = 42;
+const MIN_VALUES_PER_GROUP: usize = 1;
+const MAX_VALUES_PER_GROUP: usize = 15;
+
+fn random_group_sizes() -> Vec<usize> {
+    let mut rng = StdRng::seed_from_u64(GROUP_SIZE_SEED);
+    (0..GROUP_COUNT)
+        .map(|_| rng.random_range(MIN_VALUES_PER_GROUP..=MAX_VALUES_PER_GROUP))
+        .collect()
+}
+
+fn total_element_count(group_sizes: &[usize]) -> usize {
+    group_sizes.iter().sum()
+}
+
+fn contiguous_list_view(elements: ArrayRef, group_sizes: &[usize]) -> ArrayRef {
+    let mut offset = 0usize;
+    let offsets: Buffer<u32> = group_sizes
+        .iter()
+        .map(|&size| {
+            let current_offset = offset;
+            offset += size;
+            current_offset as u32
+        })
+        .collect();
+    let sizes: Buffer<u32> = group_sizes.iter().map(|&size| size as u32).collect();
+
+    assert_eq!(elements.len(), total_element_count(group_sizes));
+
+    ListViewArray::try_new(
+        elements,
+        offsets.into_array(),
+        sizes.into_array(),
+        Validity::NonNullable,
+    )
+    .unwrap()
+    .into_array()
+}
+
+fn i32_nullable_all_valid_input() -> ArrayRef {
+    let group_sizes = random_group_sizes();
+    let element_count = total_element_count(&group_sizes);
+    let values: Buffer<i32> = (0..element_count)
+        .map(|i| (i % 1024) as i32 - 512)
+        .collect();
+    let validity = Validity::from_iter(std::iter::repeat_n(true, element_count));
+    contiguous_list_view(
+        PrimitiveArray::new(values, validity).into_array(),
+        &group_sizes,
+    )
+}
+
+fn i32_clustered_nulls_input() -> ArrayRef {
+    let group_sizes = random_group_sizes();
+    let element_count = total_element_count(&group_sizes);
+    let values = (0..element_count).map(|i| {
+        if (i / 16) % 8 == 0 {
+            None
+        } else {
+            Some((i % 1024) as i32 - 512)
+        }
+    });
+    contiguous_list_view(
+        PrimitiveArray::from_option_iter(values).into_array(),
+        &group_sizes,
+    )
+}
+
+fn f64_all_valid_input() -> ArrayRef {
+    let group_sizes = random_group_sizes();
+    let element_count = total_element_count(&group_sizes);
+    let mut rng = StdRng::seed_from_u64(GROUP_SIZE_SEED);
+    let values: Buffer<f64> = (0..element_count)
+        .map(|_| rng.random_range(-1000.0..1000.0))
+        .collect();
+    contiguous_list_view(
+        PrimitiveArray::new(values, Validity::NonNullable).into_array(),
+        &group_sizes,
+    )
+}
+
+fn f64_clustered_nulls_input() -> ArrayRef {
+    let group_sizes = random_group_sizes();
+    let element_count = total_element_count(&group_sizes);
+    let mut rng = StdRng::seed_from_u64(GROUP_SIZE_SEED);
+    let values = (0..element_count).map(|i| {
+        if (i / 16) % 8 == 0 {
+            None
+        } else {
+            Some(rng.random_range(-1000.0f64..1000.0))
+        }
+    });
+    contiguous_list_view(
+        PrimitiveArray::from_option_iter(values).into_array(),
+        &group_sizes,
+    )
+}
+
+fn varbinview_input() -> ArrayRef {
+    let group_sizes = random_group_sizes();
+    let element_count = total_element_count(&group_sizes);
+    let values: Vec<String> = (0..element_count)
+        .map(|i| format!("value-{i:06}"))
+        .collect();
+    contiguous_list_view(
+        VarBinViewArray::from_iter_str(values.iter().map(String::as_str)).into_array(),
+        &group_sizes,
+    )
+}
+
+fn list_element_dtype(list_view: &ArrayRef) -> DType {
+    match list_view.dtype() {
+        DType::List(element_dtype, _) => element_dtype.as_ref().clone(),
+        dtype => unreachable!("expected List dtype, got {dtype}"),
+    }
+}
+
+fn grouped_accumulator<V>(list_view: &ArrayRef, vtable: V) -> ArrayRef
+where
+    V: AggregateFnVTable<Options = EmptyOptions> + Clone,
+{
+    let mut acc =
+        GroupedAccumulator::try_new(vtable, EmptyOptions, list_element_dtype(list_view)).unwrap();
+    acc.accumulate_list(list_view, &mut LEGACY_SESSION.create_execution_ctx())
+        .unwrap();
+    divan::black_box(acc.finish().unwrap())
+}
+
+#[divan::bench]
+fn sum_i32_nullable_all_valid(bencher: Bencher) {
+    let input = i32_nullable_all_valid_input();
+    bencher
+        .with_inputs(|| &input)
+        .bench_refs(|input| grouped_accumulator(input, Sum));
+}
+
+#[divan::bench]
+fn sum_i32_clustered_nulls(bencher: Bencher) {
+    let input = i32_clustered_nulls_input();
+    bencher
+        .with_inputs(|| &input)
+        .bench_refs(|input| grouped_accumulator(input, Sum));
+}
+
+#[divan::bench]
+fn sum_f64_all_valid(bencher: Bencher) {
+    let input = f64_all_valid_input();
+    bencher
+        .with_inputs(|| &input)
+        .bench_refs(|input| grouped_accumulator(input, Sum));
+}
+
+#[divan::bench]
+fn sum_f64_clustered_nulls(bencher: Bencher) {
+    let input = f64_clustered_nulls_input();
+    bencher
+        .with_inputs(|| &input)
+        .bench_refs(|input| grouped_accumulator(input, Sum));
+}
+
+#[divan::bench]
+fn count_i32_clustered_nulls(bencher: Bencher) {
+    let input = i32_clustered_nulls_input();
+    bencher
+        .with_inputs(|| &input)
+        .bench_refs(|input| grouped_accumulator(input, Count));
+}
+
+#[divan::bench]
+fn count_varbinview(bencher: Bencher) {
+    let input = varbinview_input();
+    bencher
+        .with_inputs(|| &input)
+        .bench_refs(|input| grouped_accumulator(input, Count));
+}
diff --git a/vortex-array/benches/aggregate_max.rs b/vortex-array/benches/aggregate_max.rs
index 8962ade2974..14bf13792dd 100644
--- a/vortex-array/benches/aggregate_max.rs
+++ b/vortex-array/benches/aggregate_max.rs
@@ -25,11 +25,13 @@ fn max_i32(bencher: Bencher) {
     let mut rng = StdRng::seed_from_u64(1);
     let data: Vec<i32> = (0..N).map(|_| rng.random::<i32>()).collect();
     bencher
-        .with_inputs(|| PrimitiveArray::from_iter(data.iter().copied()).into_array())
-        .bench_refs(|a| {
-            a.statistics()
-                .compute_max::<i32>(&mut SESSION.create_execution_ctx())
-        });
+        .with_inputs(|| {
+            (
+                PrimitiveArray::from_iter(data.iter().copied()).into_array(),
+                SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(a, ctx)| a.statistics().compute_max::<i32>(ctx));
 }
 
 #[divan::bench]
@@ -37,11 +39,13 @@ fn max_i64(bencher: Bencher) {
     let mut rng = StdRng::seed_from_u64(2);
     let data: Vec<i64> = (0..N).map(|_| rng.random::<i64>()).collect();
     bencher
-        .with_inputs(|| PrimitiveArray::from_iter(data.iter().copied()).into_array())
-        .bench_refs(|a| {
-            a.statistics()
-                .compute_max::<i64>(&mut SESSION.create_execution_ctx())
-        });
+        .with_inputs(|| {
+            (
+                PrimitiveArray::from_iter(data.iter().copied()).into_array(),
+                SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(a, ctx)| a.statistics().compute_max::<i64>(ctx));
 }
 
 #[divan::bench]
@@ -49,11 +53,13 @@ fn max_f64(bencher: Bencher) {
     let mut rng = StdRng::seed_from_u64(3);
     let data: Vec<f64> = (0..N).map(|_| rng.random::<f64>()).collect();
     bencher
-        .with_inputs(|| PrimitiveArray::from_iter(data.iter().copied()).into_array())
-        .bench_refs(|a| {
-            a.statistics()
-                .compute_max::<f64>(&mut SESSION.create_execution_ctx())
-        });
+        .with_inputs(|| {
+            (
+                PrimitiveArray::from_iter(data.iter().copied()).into_array(),
+                SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(a, ctx)| a.statistics().compute_max::<f64>(ctx));
 }
 
 // Clustered nulls: long valid runs broken up by null blocks (run-based path's best case).
@@ -70,11 +76,13 @@ fn max_i32_nulls_clustered(bencher: Bencher) {
         })
         .collect();
     bencher
-        .with_inputs(|| PrimitiveArray::from_option_iter(data.iter().copied()).into_array())
-        .bench_refs(|a| {
-            a.statistics()
-                .compute_max::<i32>(&mut SESSION.create_execution_ctx())
-        });
+        .with_inputs(|| {
+            (
+                PrimitiveArray::from_option_iter(data.iter().copied()).into_array(),
+                SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(a, ctx)| a.statistics().compute_max::<i32>(ctx));
 }
 
 // Scattered nulls: ~50% random nulls producing many short runs (run-based path's worst case).
@@ -85,9 +93,11 @@ fn max_i32_nulls_scattered(bencher: Bencher) {
         .map(|_| rng.random_bool(0.5).then(|| rng.random::<i32>()))
         .collect();
     bencher
-        .with_inputs(|| PrimitiveArray::from_option_iter(data.iter().copied()).into_array())
-        .bench_refs(|a| {
-            a.statistics()
-                .compute_max::<i32>(&mut SESSION.create_execution_ctx())
-        });
+        .with_inputs(|| {
+            (
+                PrimitiveArray::from_option_iter(data.iter().copied()).into_array(),
+                SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(a, ctx)| a.statistics().compute_max::<i32>(ctx));
 }
diff --git a/vortex-array/benches/aggregate_sum.rs b/vortex-array/benches/aggregate_sum.rs
index db4bf5b284a..b076bb80b5f 100644
--- a/vortex-array/benches/aggregate_sum.rs
+++ b/vortex-array/benches/aggregate_sum.rs
@@ -26,11 +26,13 @@ fn sum_i32(bencher: Bencher) {
     let mut rng = StdRng::seed_from_u64(1);
     let data: Vec<i32> = (0..N).map(|_| rng.random_range(-1000..1000)).collect();
     bencher
-        .with_inputs(|| PrimitiveArray::from_iter(data.iter().copied()).into_array())
-        .bench_refs(|a| {
-            a.statistics()
-                .compute_as::<i64>(Stat::Sum, &mut SESSION.create_execution_ctx())
-        });
+        .with_inputs(|| {
+            (
+                PrimitiveArray::from_iter(data.iter().copied()).into_array(),
+                SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(a, ctx)| a.statistics().compute_as::<i64>(Stat::Sum, ctx));
 }
 
 #[divan::bench]
@@ -38,11 +40,13 @@ fn sum_u32(bencher: Bencher) {
     let mut rng = StdRng::seed_from_u64(2);
     let data: Vec<u32> = (0..N).map(|_| rng.random_range(0..2000)).collect();
     bencher
-        .with_inputs(|| PrimitiveArray::from_iter(data.iter().copied()).into_array())
-        .bench_refs(|a| {
-            a.statistics()
-                .compute_as::<u64>(Stat::Sum, &mut SESSION.create_execution_ctx())
-        });
+        .with_inputs(|| {
+            (
+                PrimitiveArray::from_iter(data.iter().copied()).into_array(),
+                SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(a, ctx)| a.statistics().compute_as::<u64>(Stat::Sum, ctx));
 }
 
 #[divan::bench]
@@ -50,11 +54,49 @@ fn sum_i64(bencher: Bencher) {
     let mut rng = StdRng::seed_from_u64(3);
     let data: Vec<i64> = (0..N).map(|_| rng.random_range(-1000..1000)).collect();
     bencher
-        .with_inputs(|| PrimitiveArray::from_iter(data.iter().copied()).into_array())
-        .bench_refs(|a| {
-            a.statistics()
-                .compute_as::<i64>(Stat::Sum, &mut SESSION.create_execution_ctx())
-        });
+        .with_inputs(|| {
+            (
+                PrimitiveArray::from_iter(data.iter().copied()).into_array(),
+                SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(a, ctx)| a.statistics().compute_as::<i64>(Stat::Sum, ctx));
+}
+
+#[divan::bench]
+fn sum_f64(bencher: Bencher) {
+    let mut rng = StdRng::seed_from_u64(6);
+    let data: Vec<f64> = (0..N).map(|_| rng.random_range(-1000.0..1000.0)).collect();
+    bencher
+        .with_inputs(|| {
+            (
+                PrimitiveArray::from_iter(data.iter().copied()).into_array(),
+                SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(a, ctx)| a.statistics().compute_as::<f64>(Stat::Sum, ctx));
+}
+
+#[divan::bench]
+fn sum_f64_nulls_clustered(bencher: Bencher) {
+    let mut rng = StdRng::seed_from_u64(7);
+    let data: Vec<Option<f64>> = (0..N)
+        .map(|i| {
+            if (i / 64) % 10 == 0 {
+                None
+            } else {
+                Some(rng.random_range(-1000.0..1000.0))
+            }
+        })
+        .collect();
+    bencher
+        .with_inputs(|| {
+            (
+                PrimitiveArray::from_option_iter(data.iter().copied()).into_array(),
+                SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(a, ctx)| a.statistics().compute_as::<f64>(Stat::Sum, ctx));
 }
 
 // Clustered nulls: long runs of valid values broken up by occasional null blocks. This is the
@@ -72,11 +114,13 @@ fn sum_i32_nulls_clustered(bencher: Bencher) {
         })
         .collect();
     bencher
-        .with_inputs(|| PrimitiveArray::from_option_iter(data.iter().copied()).into_array())
-        .bench_refs(|a| {
-            a.statistics()
-                .compute_as::<i64>(Stat::Sum, &mut SESSION.create_execution_ctx())
-        });
+        .with_inputs(|| {
+            (
+                PrimitiveArray::from_option_iter(data.iter().copied()).into_array(),
+                SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(a, ctx)| a.statistics().compute_as::<i64>(Stat::Sum, ctx));
 }
 
 // Scattered nulls: ~50% nulls placed at random, producing many short runs. This is the worst case
@@ -88,9 +132,11 @@ fn sum_i32_nulls_scattered(bencher: Bencher) {
         .map(|_| rng.random_bool(0.5).then(|| rng.random_range(-1000..1000)))
         .collect();
     bencher
-        .with_inputs(|| PrimitiveArray::from_option_iter(data.iter().copied()).into_array())
-        .bench_refs(|a| {
-            a.statistics()
-                .compute_as::<i64>(Stat::Sum, &mut SESSION.create_execution_ctx())
-        });
+        .with_inputs(|| {
+            (
+                PrimitiveArray::from_option_iter(data.iter().copied()).into_array(),
+                SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(a, ctx)| a.statistics().compute_as::<i64>(Stat::Sum, ctx));
 }
diff --git a/vortex-array/benches/bool_zip.rs b/vortex-array/benches/bool_zip.rs
new file mode 100644
index 00000000000..c537d7b074f
--- /dev/null
+++ b/vortex-array/benches/bool_zip.rs
@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![expect(clippy::unwrap_used)]
+
+use divan::Bencher;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::LEGACY_SESSION;
+use vortex_array::RecursiveCanonical;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::BoolArray;
+use vortex_array::builtins::ArrayBuiltins;
+use vortex_mask::Mask;
+
+fn main() {
+    divan::main();
+}
+
+const LEN: usize = 65_536;
+
+/// Fragmented (alternating) mask: the worst case for the generic per-run builder this kernel
+/// replaces. The branchless bitmap blend is mask-shape-independent, so one shape suffices.
+fn mask() -> Mask {
+    Mask::from_iter((0..LEN).map(|i| i.is_multiple_of(2)))
+}
+
+#[divan::bench]
+fn nonnull(bencher: Bencher) {
+    let if_true = BoolArray::from_iter((0..LEN).map(|i| i.is_multiple_of(2))).into_array();
+    let if_false = BoolArray::from_iter((0..LEN).map(|i| i.is_multiple_of(3))).into_array();
+    run(bencher, if_true, if_false);
+}
+
+#[divan::bench]
+fn nullable(bencher: Bencher) {
+    let if_true = BoolArray::from_iter(
+        (0..LEN).map(|i| (!i.is_multiple_of(7)).then_some(i.is_multiple_of(2))),
+    )
+    .into_array();
+    let if_false = BoolArray::from_iter(
+        (0..LEN).map(|i| (!i.is_multiple_of(5)).then_some(i.is_multiple_of(3))),
+    )
+    .into_array();
+    run(bencher, if_true, if_false);
+}
+
+fn run(bencher: Bencher, if_true: ArrayRef, if_false: ArrayRef) {
+    let mask = mask();
+    bencher
+        .with_inputs(|| {
+            (
+                if_true.clone(),
+                if_false.clone(),
+                mask.clone().into_array(),
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(t, f, m, ctx)| {
+            m.zip(t.clone(), f.clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+                .unwrap();
+        });
+}
diff --git a/vortex-array/benches/cast_primitive.rs b/vortex-array/benches/cast_primitive.rs
index 86895fb2ce7..060a8290a2a 100644
--- a/vortex-array/benches/cast_primitive.rs
+++ b/vortex-array/benches/cast_primitive.rs
@@ -1,11 +1,12 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use rand::prelude::*;
 use vortex_array::Canonical;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::builtins::ArrayBuiltins;
@@ -13,6 +14,8 @@ use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
 use vortex_array::dtype::PType;
 use vortex_array::expr::stats::Stat;
+use vortex_array::session::ArraySession;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
@@ -20,6 +23,9 @@ fn main() {
 
 const N: usize = 100_000;
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 #[divan::bench]
 fn cast_u16_to_u32(bencher: Bencher) {
     let mut rng = StdRng::seed_from_u64(42);
@@ -34,15 +40,14 @@ fn cast_u16_to_u32(bencher: Bencher) {
     .into_array();
     // Pre-compute min/max so values_fit_in is a cache hit during the benchmark.
     arr.statistics()
-        .compute_all(
-            &[Stat::Min, Stat::Max],
-            &mut LEGACY_SESSION.create_execution_ctx(),
-        )
+        .compute_all(&[Stat::Min, Stat::Max], &mut SESSION.create_execution_ctx())
         .ok();
-    bencher.with_inputs(|| arr.clone()).bench_refs(|a| {
-        #[expect(clippy::unwrap_used)]
-        a.cast(DType::Primitive(PType::U32, Nullability::Nullable))
-            .unwrap()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
-    });
+    bencher
+        .with_inputs(|| (arr.clone(), SESSION.create_execution_ctx()))
+        .bench_refs(|(a, ctx)| {
+            #[expect(clippy::unwrap_used)]
+            a.cast(DType::Primitive(PType::U32, Nullability::Nullable))
+                .unwrap()
+                .execute::<Canonical>(ctx)
+        });
 }
diff --git a/vortex-array/benches/chunked_fsl_canonicalize.rs b/vortex-array/benches/chunked_fsl_canonicalize.rs
index d267415cc4e..ac9962046de 100644
--- a/vortex-array/benches/chunked_fsl_canonicalize.rs
+++ b/vortex-array/benches/chunked_fsl_canonicalize.rs
@@ -10,20 +10,26 @@
 #![expect(clippy::cast_possible_truncation)]
 #![expect(clippy::unwrap_used)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use vortex_array::Canonical;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::ChunkedArray;
 use vortex_array::arrays::FixedSizeListArray;
+use vortex_array::session::ArraySession;
 use vortex_array::validity::Validity;
 use vortex_buffer::Buffer;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
 }
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 /// Number of lists in each chunk.
 const LISTS_PER_CHUNK: usize = 1_000;
 
@@ -60,7 +66,7 @@ fn canonicalize<const LIST_SIZE: usize>(bencher: Bencher, num_chunks: usize) {
     let chunked = create_chunked_fsl(LIST_SIZE, num_chunks).into_array();
 
     bencher
-        .with_inputs(|| (&chunked, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&chunked, SESSION.create_execution_ctx()))
         .bench_refs(|(array, execution_ctx)| {
             array.clone().execute::<Canonical>(execution_ctx).unwrap()
         });
diff --git a/vortex-array/benches/dict_compare.rs b/vortex-array/benches/dict_compare.rs
index 54a3faf8224..401393495dd 100644
--- a/vortex-array/benches/dict_compare.rs
+++ b/vortex-array/benches/dict_compare.rs
@@ -4,10 +4,10 @@
 #![expect(clippy::unwrap_used)]
 
 use std::str::from_utf8;
+use std::sync::LazyLock;
 
 use vortex_array::Canonical;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::RecursiveCanonical;
 use vortex_array::VortexSessionExecute;
 use vortex_array::accessor::ArrayAccessor;
@@ -22,12 +22,16 @@ use vortex_array::expr::eq;
 use vortex_array::expr::lit;
 use vortex_array::expr::root;
 use vortex_array::scalar_fn::fns::operators::Operator;
+use vortex_array::session::ArraySession;
 use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
 }
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 const LENGTH_AND_UNIQUE_VALUES: &[(usize, usize)] = &[
     // length, unique_values
     (10_000, 2),
@@ -51,7 +55,7 @@ fn bench_compare_primitive(bencher: divan::Bencher, (len, uniqueness): (usize, u
     let primitive_arr = gen_primitive_for_dict::<i32>(len, uniqueness);
     let dict = dict_encode(
         &primitive_arr.clone().into_array(),
-        &mut LEGACY_SESSION.create_execution_ctx(),
+        &mut SESSION.create_execution_ctx(),
     )
     .unwrap();
     let value = primitive_arr.as_slice::<i32>()[0];
@@ -74,7 +78,7 @@ fn bench_compare_varbin(bencher: divan::Bencher, (len, uniqueness): (usize, usiz
     let varbin_arr = VarBinArray::from(gen_varbin_words(len, uniqueness));
     let dict = dict_encode(
         &varbin_arr.clone().into_array(),
-        &mut LEGACY_SESSION.create_execution_ctx(),
+        &mut SESSION.create_execution_ctx(),
     )
     .unwrap();
     let bytes = varbin_arr.with_iterator(|i| i.next().unwrap().unwrap().to_vec());
@@ -98,7 +102,7 @@ fn bench_compare_varbinview(bencher: divan::Bencher, (len, uniqueness): (usize,
     let varbinview_arr = VarBinViewArray::from_iter_str(gen_varbin_words(len, uniqueness));
     let dict = dict_encode(
         &varbinview_arr.clone().into_array(),
-        &mut LEGACY_SESSION.create_execution_ctx(),
+        &mut SESSION.create_execution_ctx(),
     )
     .unwrap();
     let bytes = varbinview_arr.with_iterator(|i| i.next().unwrap().unwrap().to_vec());
@@ -137,7 +141,7 @@ fn bench_compare_sliced_dict_primitive(
     let primitive_arr = gen_primitive_for_dict::<i32>(codes_len.max(values_len), values_len);
     let dict = dict_encode(
         &primitive_arr.clone().into_array(),
-        &mut LEGACY_SESSION.create_execution_ctx(),
+        &mut SESSION.create_execution_ctx(),
     )
     .unwrap();
     let dict = dict.into_array().slice(0..codes_len).unwrap();
@@ -163,7 +167,7 @@ fn bench_compare_sliced_dict_varbinview(
     let varbin_arr = VarBinArray::from(gen_varbin_words(codes_len.max(values_len), values_len));
     let dict = dict_encode(
         &varbin_arr.clone().into_array(),
-        &mut LEGACY_SESSION.create_execution_ctx(),
+        &mut SESSION.create_execution_ctx(),
     )
     .unwrap();
     let dict = dict.into_array().slice(0..codes_len).unwrap();
diff --git a/vortex-array/benches/dict_compress.rs b/vortex-array/benches/dict_compress.rs
index cf7f647a7e0..21d427bd7f8 100644
--- a/vortex-array/benches/dict_compress.rs
+++ b/vortex-array/benches/dict_compress.rs
@@ -3,12 +3,13 @@
 
 #![expect(clippy::unwrap_used)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use rand::distr::Distribution;
 use rand::distr::StandardUniform;
 use vortex_array::Canonical;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::VarBinArray;
 use vortex_array::arrays::VarBinViewArray;
@@ -16,6 +17,8 @@ use vortex_array::arrays::dict_test::gen_primitive_for_dict;
 use vortex_array::arrays::dict_test::gen_varbin_words;
 use vortex_array::builders::dict::dict_encode;
 use vortex_array::dtype::NativePType;
+use vortex_array::session::ArraySession;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
@@ -35,6 +38,9 @@ const BENCH_ARGS: &[(usize, usize)] = &[
     (10_000, 512),
 ];
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 #[divan::bench(types = [u8, f32, i64], args = BENCH_ARGS)]
 fn encode_primitives<T>(bencher: Bencher, (len, unique_values): (usize, usize))
 where
@@ -43,36 +49,27 @@ where
 {
     let primitive_arr = gen_primitive_for_dict::<T>(len, unique_values);
 
-    bencher.with_inputs(|| &primitive_arr).bench_refs(|arr| {
-        dict_encode(
-            &arr.clone().into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
-        )
-    });
+    bencher
+        .with_inputs(|| (&primitive_arr, SESSION.create_execution_ctx()))
+        .bench_refs(|(arr, ctx)| dict_encode(&arr.clone().into_array(), ctx));
 }
 
 #[divan::bench(args = BENCH_ARGS)]
 fn encode_varbin(bencher: Bencher, (len, unique_values): (usize, usize)) {
     let varbin_arr = VarBinArray::from(gen_varbin_words(len, unique_values));
 
-    bencher.with_inputs(|| &varbin_arr).bench_refs(|arr| {
-        dict_encode(
-            &arr.clone().into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
-        )
-    });
+    bencher
+        .with_inputs(|| (&varbin_arr, SESSION.create_execution_ctx()))
+        .bench_refs(|(arr, ctx)| dict_encode(&arr.clone().into_array(), ctx));
 }
 
 #[divan::bench(args = BENCH_ARGS)]
 fn encode_varbinview(bencher: Bencher, (len, unique_values): (usize, usize)) {
     let varbinview_arr = VarBinViewArray::from_iter_str(gen_varbin_words(len, unique_values));
 
-    bencher.with_inputs(|| &varbinview_arr).bench_refs(|arr| {
-        dict_encode(
-            &arr.clone().into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
-        )
-    });
+    bencher
+        .with_inputs(|| (&varbinview_arr, SESSION.create_execution_ctx()))
+        .bench_refs(|(arr, ctx)| dict_encode(&arr.clone().into_array(), ctx));
 }
 
 #[divan::bench(types = [u8, f32, i64], args = BENCH_ARGS)]
@@ -84,13 +81,13 @@ where
     let primitive_arr = gen_primitive_for_dict::<T>(len, unique_values);
     let dict = dict_encode(
         &primitive_arr.into_array(),
-        &mut LEGACY_SESSION.create_execution_ctx(),
+        &mut SESSION.create_execution_ctx(),
     )
     .unwrap()
     .into_array();
 
     bencher
-        .with_inputs(|| (&dict, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&dict, SESSION.create_execution_ctx()))
         .bench_refs(|(dict, ctx)| (**dict).clone().execute::<Canonical>(ctx));
 }
 
@@ -99,13 +96,13 @@ fn decode_varbin(bencher: Bencher, (len, unique_values): (usize, usize)) {
     let varbin_arr = VarBinArray::from(gen_varbin_words(len, unique_values));
     let dict = dict_encode(
         &varbin_arr.into_array(),
-        &mut LEGACY_SESSION.create_execution_ctx(),
+        &mut SESSION.create_execution_ctx(),
     )
     .unwrap()
     .into_array();
 
     bencher
-        .with_inputs(|| (&dict, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&dict, SESSION.create_execution_ctx()))
         .bench_refs(|(dict, ctx)| (**dict).clone().execute::<Canonical>(ctx));
 }
 
@@ -114,12 +111,12 @@ fn decode_varbinview(bencher: Bencher, (len, unique_values): (usize, usize)) {
     let varbinview_arr = VarBinViewArray::from_iter_str(gen_varbin_words(len, unique_values));
     let dict = dict_encode(
         &varbinview_arr.into_array(),
-        &mut LEGACY_SESSION.create_execution_ctx(),
+        &mut SESSION.create_execution_ctx(),
     )
     .unwrap()
     .into_array();
 
     bencher
-        .with_inputs(|| (&dict, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&dict, SESSION.create_execution_ctx()))
         .bench_refs(|(dict, ctx)| (**dict).clone().execute::<Canonical>(ctx));
 }
diff --git a/vortex-array/benches/filter_bool.rs b/vortex-array/benches/filter_bool.rs
index 5699fdb19cb..6c240db6b60 100644
--- a/vortex-array/benches/filter_bool.rs
+++ b/vortex-array/benches/filter_bool.rs
@@ -11,20 +11,26 @@
 #![expect(clippy::cast_sign_loss)]
 #![expect(clippy::cast_precision_loss)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use rand::prelude::*;
 use rand_distr::Zipf;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::RecursiveCanonical;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::BoolArray;
+use vortex_array::session::ArraySession;
 use vortex_buffer::BitBuffer;
 use vortex_mask::Mask;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
 }
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 const SIZES: &[usize] = &[1_000, 10_000, 100_000, 250_000];
 const DENSITY_SWEEP_SIZE: usize = 100_000;
 const ARRAY_SEED: u64 = 42;
@@ -142,7 +148,7 @@ fn filter_random_by_mostly_true(bencher: Bencher, n: usize) {
             (
                 array.clone(),
                 make_mostly_true(n, &mut mask_rng()),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(array, m, ctx)| {
@@ -162,7 +168,7 @@ fn filter_random_by_mostly_false(bencher: Bencher, n: usize) {
             (
                 array.clone(),
                 make_mostly_false(n, &mut mask_rng()),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(array, m, ctx)| {
@@ -182,7 +188,7 @@ fn filter_random_by_random(bencher: Bencher, n: usize) {
             (
                 array.clone(),
                 make_random(n, &mut mask_rng()),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(array, m, ctx)| {
@@ -202,7 +208,7 @@ fn filter_random_by_correlated_runs(bencher: Bencher, n: usize) {
             (
                 array.clone(),
                 make_correlated_runs(n, &mut mask_rng()),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(array, m, ctx)| {
@@ -222,7 +228,7 @@ fn filter_random_by_power_law(bencher: Bencher, n: usize) {
             (
                 array.clone(),
                 make_power_law(n, &mut mask_rng()),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(array, m, ctx)| {
@@ -244,7 +250,7 @@ fn filter_powerlaw_by_mostly_true(bencher: Bencher, n: usize) {
             (
                 array.clone(),
                 make_mostly_true(n, &mut mask_rng()),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(array, m, ctx)| {
@@ -264,7 +270,7 @@ fn filter_powerlaw_by_mostly_false(bencher: Bencher, n: usize) {
             (
                 array.clone(),
                 make_mostly_false(n, &mut mask_rng()),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(array, m, ctx)| {
@@ -284,7 +290,7 @@ fn filter_powerlaw_by_random(bencher: Bencher, n: usize) {
             (
                 array.clone(),
                 make_random(n, &mut mask_rng()),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(array, m, ctx)| {
@@ -304,7 +310,7 @@ fn filter_powerlaw_by_correlated_runs(bencher: Bencher, n: usize) {
             (
                 array.clone(),
                 make_correlated_runs(n, &mut mask_rng()),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(array, m, ctx)| {
@@ -324,7 +330,7 @@ fn filter_powerlaw_by_power_law(bencher: Bencher, n: usize) {
             (
                 array.clone(),
                 make_power_law(n, &mut mask_rng()),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(array, m, ctx)| {
@@ -350,7 +356,7 @@ fn density_sweep_random(bencher: Bencher, density: f64) {
             (
                 array.clone(),
                 make_density_mask(DENSITY_SWEEP_SIZE, density, &mut mask_rng()),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(array, m, ctx)| {
@@ -371,7 +377,7 @@ fn density_sweep_dense_runs(bencher: Bencher, density: f64) {
             (
                 array.clone(),
                 make_dense_runs(DENSITY_SWEEP_SIZE, false_rate, &mut mask_rng()),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(array, m, ctx)| {
@@ -391,7 +397,7 @@ fn density_sweep_single_slice(bencher: Bencher, density: f64) {
             (
                 array.clone(),
                 make_single_slice(DENSITY_SWEEP_SIZE, density),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(array, m, ctx)| {
@@ -415,7 +421,7 @@ fn filter_all_true(bencher: Bencher, n: usize) {
             (
                 array.clone(),
                 Mask::new_true(n),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(array, m, ctx)| {
@@ -437,7 +443,7 @@ fn filter_one_false(bencher: Bencher, n: usize) {
             (
                 array.clone(),
                 Mask::from_buffer(BitBuffer::from_iter(bits)),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(array, m, ctx)| {
@@ -457,7 +463,7 @@ fn filter_ultra_sparse(bencher: Bencher, n: usize) {
             (
                 array.clone(),
                 make_density_mask(n, 0.0001, &mut mask_rng()),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(array, m, ctx)| {
diff --git a/vortex-array/benches/interleave.rs b/vortex-array/benches/interleave.rs
new file mode 100644
index 00000000000..cba7f6a910e
--- /dev/null
+++ b/vortex-array/benches/interleave.rs
@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![expect(clippy::unwrap_used)]
+
+use divan::Bencher;
+use rand::RngExt;
+use rand::SeedableRng;
+use rand::distr::Uniform;
+use rand::prelude::StdRng;
+use vortex_array::Canonical;
+use vortex_array::IntoArray;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::BoolArray;
+use vortex_array::arrays::InterleaveArray;
+use vortex_buffer::Buffer;
+use vortex_session::VortexSession;
+
+fn main() {
+    divan::main();
+}
+
+const ARRAY_SIZE: usize = 8_192;
+
+/// Builds `num_branches` boolean value arrays plus random `(array_indices, row_indices)` selectors
+/// describing a full random-access gather of `ARRAY_SIZE` output rows.
+fn inputs(
+    num_branches: usize,
+    nullable: bool,
+) -> (Vec<vortex_array::ArrayRef>, Buffer<u32>, Buffer<u32>) {
+    let mut rng = StdRng::seed_from_u64(0);
+    let bit = Uniform::new(0u8, 2).unwrap();
+
+    let values = (0..num_branches)
+        .map(|_| {
+            if nullable {
+                BoolArray::from_iter(
+                    (0..ARRAY_SIZE).map(|_| (rng.sample(bit) == 0).then_some(rng.sample(bit) == 0)),
+                )
+                .into_array()
+            } else {
+                BoolArray::from_iter((0..ARRAY_SIZE).map(|_| rng.sample(bit) == 0)).into_array()
+            }
+        })
+        .collect();
+
+    let branch = Uniform::new(0u32, u32::try_from(num_branches).unwrap()).unwrap();
+    let row = Uniform::new(0u32, u32::try_from(ARRAY_SIZE).unwrap()).unwrap();
+    let array_indices: Buffer<u32> = (0..ARRAY_SIZE).map(|_| rng.sample(branch)).collect();
+    let row_indices: Buffer<u32> = (0..ARRAY_SIZE).map(|_| rng.sample(row)).collect();
+    (values, array_indices, row_indices)
+}
+
+#[divan::bench(args = [2, 4])]
+fn interleave_bool(bencher: Bencher, num_branches: usize) {
+    let (values, array_indices, row_indices) = inputs(num_branches, false);
+    let session = VortexSession::empty();
+    bencher
+        .with_inputs(|| {
+            (
+                InterleaveArray::try_new(
+                    values.clone(),
+                    array_indices.clone().into_array(),
+                    row_indices.clone().into_array(),
+                )
+                .unwrap()
+                .into_array(),
+                session.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, ctx)| array.clone().execute::<Canonical>(ctx));
+}
+
+#[divan::bench(args = [2, 4])]
+fn interleave_bool_nullable(bencher: Bencher, num_branches: usize) {
+    let (values, array_indices, row_indices) = inputs(num_branches, true);
+    let session = VortexSession::empty();
+    bencher
+        .with_inputs(|| {
+            (
+                InterleaveArray::try_new(
+                    values.clone(),
+                    array_indices.clone().into_array(),
+                    row_indices.clone().into_array(),
+                )
+                .unwrap()
+                .into_array(),
+                session.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(array, ctx)| array.clone().execute::<Canonical>(ctx));
+}
diff --git a/vortex-array/benches/listview_rebuild.rs b/vortex-array/benches/listview_rebuild.rs
index 00781b1a534..31fdaf5e890 100644
--- a/vortex-array/benches/listview_rebuild.rs
+++ b/vortex-array/benches/listview_rebuild.rs
@@ -6,10 +6,11 @@
 #![expect(clippy::unwrap_used)]
 #![expect(clippy::cast_possible_truncation)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use vortex_array::Canonical;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::FixedSizeListArray;
 use vortex_array::arrays::ListArray;
@@ -20,13 +21,19 @@ use vortex_array::arrays::VarBinViewArray;
 use vortex_array::arrays::listview::ListViewArrayExt;
 use vortex_array::arrays::listview::ListViewRebuildMode;
 use vortex_array::dtype::FieldNames;
+use vortex_array::session::ArraySession;
 use vortex_array::validity::Validity;
 use vortex_buffer::Buffer;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
 }
 
+/// A shared session for the `ListView` rebuild benchmarks, used to create execution contexts.
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 fn make_primitive_lv(num_lists: usize, list_size: usize, step: usize) -> ListViewArray {
     let element_count = step * num_lists + list_size;
     let elements = PrimitiveArray::from_iter(0..element_count as i32).into_array();
@@ -110,92 +117,120 @@ fn make_nested_list_lv(
 #[divan::bench]
 fn i32_small(bencher: Bencher) {
     let lv = make_primitive_lv(50, 32, 32);
-    bencher.with_inputs(|| &lv).bench_refs(|lv| {
-        let rebuilt = lv.rebuild(ListViewRebuildMode::MakeZeroCopyToList).unwrap();
-        rebuilt
-            .elements()
-            .clone()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
-    });
+    bencher
+        .with_inputs(|| (&lv, SESSION.create_execution_ctx()))
+        .bench_refs(|(lv, ctx)| {
+            let rebuilt = lv
+                .rebuild(ListViewRebuildMode::MakeZeroCopyToList, ctx)
+                .unwrap();
+            rebuilt
+                .elements()
+                .clone()
+                .execute::<Canonical>(ctx)
+                .unwrap()
+        });
 }
 
 #[divan::bench]
 fn i32_small_overlapping(bencher: Bencher) {
     let lv = make_primitive_lv(50, 8, 1);
-    bencher.with_inputs(|| &lv).bench_refs(|lv| {
-        let rebuilt = lv.rebuild(ListViewRebuildMode::MakeZeroCopyToList).unwrap();
-        rebuilt
-            .elements()
-            .clone()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
-    });
+    bencher
+        .with_inputs(|| (&lv, SESSION.create_execution_ctx()))
+        .bench_refs(|(lv, ctx)| {
+            let rebuilt = lv
+                .rebuild(ListViewRebuildMode::MakeZeroCopyToList, ctx)
+                .unwrap();
+            rebuilt
+                .elements()
+                .clone()
+                .execute::<Canonical>(ctx)
+                .unwrap()
+        });
 }
 
 #[divan::bench]
 fn varbinview_small(bencher: Bencher) {
     let lv = make_varbinview_lv(50, 32, 32);
-    bencher.with_inputs(|| &lv).bench_refs(|lv| {
-        let rebuilt = lv.rebuild(ListViewRebuildMode::MakeZeroCopyToList).unwrap();
-        rebuilt
-            .elements()
-            .clone()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
-    });
+    bencher
+        .with_inputs(|| (&lv, SESSION.create_execution_ctx()))
+        .bench_refs(|(lv, ctx)| {
+            let rebuilt = lv
+                .rebuild(ListViewRebuildMode::MakeZeroCopyToList, ctx)
+                .unwrap();
+            rebuilt
+                .elements()
+                .clone()
+                .execute::<Canonical>(ctx)
+                .unwrap()
+        });
 }
 
 #[divan::bench]
 fn struct_small(bencher: Bencher) {
     let lv = make_struct_lv(50, 32, 32);
-    bencher.with_inputs(|| &lv).bench_refs(|lv| {
-        let rebuilt = lv.rebuild(ListViewRebuildMode::MakeZeroCopyToList).unwrap();
-        rebuilt
-            .elements()
-            .clone()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
-    });
+    bencher
+        .with_inputs(|| (&lv, SESSION.create_execution_ctx()))
+        .bench_refs(|(lv, ctx)| {
+            let rebuilt = lv
+                .rebuild(ListViewRebuildMode::MakeZeroCopyToList, ctx)
+                .unwrap();
+            rebuilt
+                .elements()
+                .clone()
+                .execute::<Canonical>(ctx)
+                .unwrap()
+        });
 }
 
 #[divan::bench]
 fn i32_large(bencher: Bencher) {
     let lv = make_primitive_lv(50, 1_024, 1_024);
-    bencher.with_inputs(|| &lv).bench_refs(|lv| {
-        let rebuilt = lv.rebuild(ListViewRebuildMode::MakeZeroCopyToList).unwrap();
-        rebuilt
-            .elements()
-            .clone()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
-    });
+    bencher
+        .with_inputs(|| (&lv, SESSION.create_execution_ctx()))
+        .bench_refs(|(lv, ctx)| {
+            let rebuilt = lv
+                .rebuild(ListViewRebuildMode::MakeZeroCopyToList, ctx)
+                .unwrap();
+            rebuilt
+                .elements()
+                .clone()
+                .execute::<Canonical>(ctx)
+                .unwrap()
+        });
 }
 
 #[divan::bench]
 fn varbinview_large(bencher: Bencher) {
     let lv = make_varbinview_lv(5, 1_024, 1_024);
-    bencher.with_inputs(|| &lv).bench_refs(|lv| {
-        let rebuilt = lv.rebuild(ListViewRebuildMode::MakeZeroCopyToList).unwrap();
-        rebuilt
-            .elements()
-            .clone()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
-    });
+    bencher
+        .with_inputs(|| (&lv, SESSION.create_execution_ctx()))
+        .bench_refs(|(lv, ctx)| {
+            let rebuilt = lv
+                .rebuild(ListViewRebuildMode::MakeZeroCopyToList, ctx)
+                .unwrap();
+            rebuilt
+                .elements()
+                .clone()
+                .execute::<Canonical>(ctx)
+                .unwrap()
+        });
 }
 
 #[divan::bench]
 fn struct_large(bencher: Bencher) {
     let lv = make_struct_lv(25, 1_024, 1_024);
-    bencher.with_inputs(|| &lv).bench_refs(|lv| {
-        let rebuilt = lv.rebuild(ListViewRebuildMode::MakeZeroCopyToList).unwrap();
-        rebuilt
-            .elements()
-            .clone()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
-    });
+    bencher
+        .with_inputs(|| (&lv, SESSION.create_execution_ctx()))
+        .bench_refs(|(lv, ctx)| {
+            let rebuilt = lv
+                .rebuild(ListViewRebuildMode::MakeZeroCopyToList, ctx)
+                .unwrap();
+            rebuilt
+                .elements()
+                .clone()
+                .execute::<Canonical>(ctx)
+                .unwrap()
+        });
 }
 
 #[divan::bench]
@@ -214,25 +249,33 @@ fn fsl_large(bencher: Bencher) {
         sizes.into_array(),
         Validity::NonNullable,
     );
-    bencher.with_inputs(|| &lv).bench_refs(|lv| {
-        let rebuilt = lv.rebuild(ListViewRebuildMode::MakeZeroCopyToList).unwrap();
-        rebuilt
-            .elements()
-            .clone()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
-    });
+    bencher
+        .with_inputs(|| (&lv, SESSION.create_execution_ctx()))
+        .bench_refs(|(lv, ctx)| {
+            let rebuilt = lv
+                .rebuild(ListViewRebuildMode::MakeZeroCopyToList, ctx)
+                .unwrap();
+            rebuilt
+                .elements()
+                .clone()
+                .execute::<Canonical>(ctx)
+                .unwrap()
+        });
 }
 
 #[divan::bench]
 fn list_i32_large(bencher: Bencher) {
     let lv = make_nested_list_lv(2, 512, 2);
-    bencher.with_inputs(|| &lv).bench_refs(|lv| {
-        let rebuilt = lv.rebuild(ListViewRebuildMode::MakeZeroCopyToList).unwrap();
-        rebuilt
-            .elements()
-            .clone()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
-    });
+    bencher
+        .with_inputs(|| (&lv, SESSION.create_execution_ctx()))
+        .bench_refs(|(lv, ctx)| {
+            let rebuilt = lv
+                .rebuild(ListViewRebuildMode::MakeZeroCopyToList, ctx)
+                .unwrap();
+            rebuilt
+                .elements()
+                .clone()
+                .execute::<Canonical>(ctx)
+                .unwrap()
+        });
 }
diff --git a/vortex-array/benches/primitive_zip.rs b/vortex-array/benches/primitive_zip.rs
new file mode 100644
index 00000000000..0359b464f13
--- /dev/null
+++ b/vortex-array/benches/primitive_zip.rs
@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![expect(clippy::unwrap_used)]
+#![expect(
+    clippy::cast_possible_truncation,
+    reason = "benchmark fixtures use indices that fit in the chosen widths"
+)]
+
+use divan::Bencher;
+use vortex_array::IntoArray;
+use vortex_array::LEGACY_SESSION;
+use vortex_array::RecursiveCanonical;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::builtins::ArrayBuiltins;
+use vortex_buffer::BufferMut;
+use vortex_mask::Mask;
+
+fn main() {
+    divan::main();
+}
+
+// Sized so the bench stays well under a few hundred microseconds under CodSpeed's instruction-count
+// simulation, which runs ~10x the local walltime; the branchless value blend is still exercised.
+const LEN: usize = 16_384;
+
+/// Fragmented (alternating) mask: the worst case for the generic run/slice copy path this kernel
+/// replaces. The branchless per-row blend is mask-shape-independent, so one shape suffices.
+fn mask() -> Mask {
+    Mask::from_iter((0..LEN).map(|i| i.is_multiple_of(2)))
+}
+
+#[divan::bench]
+fn nonnull(bencher: Bencher) {
+    let if_true = nonnull_array(0).into_array();
+    let if_false = nonnull_array(1_000_000).into_array();
+    run(bencher, if_true, if_false);
+}
+
+#[divan::bench]
+fn nullable(bencher: Bencher) {
+    let if_true = nullable_array(0, 7).into_array();
+    let if_false = nullable_array(1_000_000, 5).into_array();
+    run(bencher, if_true, if_false);
+}
+
+fn run(bencher: Bencher, if_true: vortex_array::ArrayRef, if_false: vortex_array::ArrayRef) {
+    let mask = mask();
+    bencher
+        .with_inputs(|| {
+            (
+                if_true.clone(),
+                if_false.clone(),
+                mask.clone().into_array(),
+                LEGACY_SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(t, f, m, ctx)| {
+            m.zip(t.clone(), f.clone())
+                .unwrap()
+                .execute::<RecursiveCanonical>(ctx)
+                .unwrap();
+        });
+}
+
+fn nonnull_array(base: i64) -> PrimitiveArray {
+    let mut values = BufferMut::<i64>::with_capacity(LEN);
+    values.extend((0..LEN as i64).map(|i| base + i));
+    PrimitiveArray::new(
+        values.freeze(),
+        vortex_array::validity::Validity::NonNullable,
+    )
+}
+
+fn nullable_array(base: i64, null_every: usize) -> PrimitiveArray {
+    PrimitiveArray::from_option_iter(
+        (0..LEN as i64).map(|i| (!(i as usize).is_multiple_of(null_every)).then_some(base + i)),
+    )
+}
diff --git a/vortex-array/benches/scalar_at_struct.rs b/vortex-array/benches/scalar_at_struct.rs
index 757d6252bb9..5e435b1000a 100644
--- a/vortex-array/benches/scalar_at_struct.rs
+++ b/vortex-array/benches/scalar_at_struct.rs
@@ -3,6 +3,8 @@
 
 #![expect(clippy::unwrap_used)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use rand::RngExt;
 use rand::SeedableRng;
@@ -10,12 +12,13 @@ use rand::distr::Uniform;
 use rand::rngs::StdRng;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::StructArray;
 use vortex_array::dtype::FieldNames;
+use vortex_array::session::ArraySession;
 use vortex_array::validity::Validity;
 use vortex_buffer::Buffer;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
@@ -24,6 +27,9 @@ fn main() {
 const ARRAY_SIZE: usize = 100_000;
 const NUM_ACCESSES: usize = 1000;
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 #[divan::bench]
 fn execute_scalar_struct_simple(bencher: Bencher) {
     let mut rng = StdRng::seed_from_u64(0);
@@ -49,11 +55,10 @@ fn execute_scalar_struct_simple(bencher: Bencher) {
         .collect();
 
     bencher
-        .with_inputs(|| (&struct_array, &indices))
-        .bench_refs(|(array, indices)| {
-            let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        .with_inputs(|| (&struct_array, &indices, SESSION.create_execution_ctx()))
+        .bench_refs(|(array, indices, ctx)| {
             for &idx in indices.iter() {
-                divan::black_box(array.execute_scalar(idx, &mut ctx).unwrap());
+                divan::black_box(array.execute_scalar(idx, ctx).unwrap());
             }
         });
 }
@@ -87,11 +92,10 @@ fn execute_scalar_struct_wide(bencher: Bencher) {
         .collect();
 
     bencher
-        .with_inputs(|| (&struct_array, &indices))
-        .bench_refs(|(array, indices)| {
-            let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        .with_inputs(|| (&struct_array, &indices, SESSION.create_execution_ctx()))
+        .bench_refs(|(array, indices, ctx)| {
             for &idx in indices.iter() {
-                divan::black_box(array.execute_scalar(idx, &mut ctx).unwrap());
+                divan::black_box(array.execute_scalar(idx, ctx).unwrap());
             }
         });
 }
diff --git a/vortex-array/benches/scalar_subtract.rs b/vortex-array/benches/scalar_subtract.rs
index bdbcdd36f3c..2eee8f3d9ff 100644
--- a/vortex-array/benches/scalar_subtract.rs
+++ b/vortex-array/benches/scalar_subtract.rs
@@ -3,25 +3,31 @@
 
 #![expect(clippy::unwrap_used)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use rand::RngExt;
 use rand::SeedableRng;
 use rand::distr::Uniform;
 use rand::rngs::StdRng;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::RecursiveCanonical;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::ChunkedArray;
 use vortex_array::arrays::ConstantArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::scalar_fn::fns::operators::Operator;
+use vortex_array::session::ArraySession;
 use vortex_buffer::Buffer;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
 }
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 #[divan::bench]
 fn scalar_subtract(bencher: Bencher) {
     let mut rng = StdRng::seed_from_u64(0);
@@ -41,7 +47,7 @@ fn scalar_subtract(bencher: Bencher) {
     let chunked = ChunkedArray::from_iter([data1, data2]).into_array();
 
     bencher
-        .with_inputs(|| (&chunked, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&chunked, SESSION.create_execution_ctx()))
         .bench_refs(|(chunked, ctx)| {
             chunked
                 .clone()
diff --git a/vortex-array/benches/slice_dict_primitive.rs b/vortex-array/benches/slice_dict_primitive.rs
index 79240bc0a0f..20a371e670e 100644
--- a/vortex-array/benches/slice_dict_primitive.rs
+++ b/vortex-array/benches/slice_dict_primitive.rs
@@ -8,7 +8,9 @@ use divan::Bencher;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
 use vortex_array::arrays::DictArray;
+use vortex_array::arrays::Primitive;
 use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::slice::SliceReduce;
 
 fn main() {
     divan::main();
@@ -46,6 +48,29 @@ fn slice_primitive_tight_loop(bencher: Bencher, len: usize) {
         });
 }
 
+#[divan::bench(args = ARRAY_LENGTHS)]
+fn slice_primitive_reduce_tight_loop(bencher: Bencher, len: usize) {
+    let arr = build_primitive(len);
+    let slice_len = 64;
+
+    let num_slices = len / slice_len;
+
+    bencher
+        .with_inputs(|| (&arr, Vec::<ArrayRef>::with_capacity(num_slices)))
+        .bench_refs(|(arr, out)| {
+            out.clear();
+            let mut offset = 0;
+            while offset + slice_len <= len {
+                out.push(
+                    <Primitive as SliceReduce>::slice(arr.as_view(), offset..offset + slice_len)
+                        .unwrap()
+                        .unwrap(),
+                );
+                offset += slice_len;
+            }
+        });
+}
+
 #[divan::bench(args = ARRAY_LENGTHS)]
 fn slice_dict_tight_loop(bencher: Bencher, len: usize) {
     let dict = build_dict(len).into_array();
diff --git a/vortex-array/benches/take_fsl.rs b/vortex-array/benches/take_fsl.rs
index baf2d4ede37..4764f5538be 100644
--- a/vortex-array/benches/take_fsl.rs
+++ b/vortex-array/benches/take_fsl.rs
@@ -10,22 +10,28 @@
 #![expect(clippy::cast_possible_truncation)]
 #![expect(clippy::unwrap_used)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use rand::RngExt;
 use rand::SeedableRng;
 use rand::rngs::StdRng;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::RecursiveCanonical;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::FixedSizeListArray;
+use vortex_array::session::ArraySession;
 use vortex_array::validity::Validity;
 use vortex_buffer::Buffer;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
 }
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 /// Number of lists in the source array.
 const NUM_LISTS: usize = 500;
 
@@ -62,7 +68,7 @@ fn take_fsl_random<const LIST_SIZE: usize>(bencher: Bencher, num_indices: usize)
     let indices_array = indices.into_array();
 
     bencher
-        .with_inputs(|| (&fsl, &indices_array, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&fsl, &indices_array, SESSION.create_execution_ctx()))
         .bench_refs(|(array, indices, execution_ctx)| {
             array
                 .clone()
@@ -88,7 +94,7 @@ fn take_fsl_nullable_random<const LIST_SIZE: usize>(bencher: Bencher, num_indice
     let indices_array = indices.into_array();
 
     bencher
-        .with_inputs(|| (&fsl, &indices_array, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&fsl, &indices_array, SESSION.create_execution_ctx()))
         .bench_refs(|(array, indices, execution_ctx)| {
             array
                 .clone()
diff --git a/vortex-array/benches/take_patches.rs b/vortex-array/benches/take_patches.rs
index f929cbd3b69..4d87f8b3c63 100644
--- a/vortex-array/benches/take_patches.rs
+++ b/vortex-array/benches/take_patches.rs
@@ -4,23 +4,29 @@
 #![expect(clippy::unwrap_used)]
 #![expect(clippy::cast_possible_truncation)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use rand::RngExt;
 use rand::SeedableRng;
 use rand::rngs::StdRng;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 #[expect(deprecated)]
 use vortex_array::ToCanonical as _;
 use vortex_array::VortexSessionExecute;
 use vortex_array::patches::Patches;
+use vortex_array::session::ArraySession;
 use vortex_buffer::Buffer;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
 }
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 const BENCH_ARGS: &[(f64, f64)] = &[
     // patches_sparsity, index_multiple
     (0.1, 1.0),
@@ -48,7 +54,7 @@ fn take_search(bencher: Bencher, (patches_sparsity, index_multiple): (f64, f64))
     );
 
     bencher
-        .with_inputs(|| (&patches, &indices, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&patches, &indices, SESSION.create_execution_ctx()))
         .bench_refs(|(patches, indices, ctx)| {
             #[expect(deprecated)]
             let prim = indices.to_primitive();
@@ -67,7 +73,7 @@ fn take_search_chunked(bencher: Bencher, (patches_sparsity, index_multiple): (f6
     );
 
     bencher
-        .with_inputs(|| (&patches, &indices, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&patches, &indices, SESSION.create_execution_ctx()))
         .bench_refs(|(patches, indices, ctx)| {
             #[expect(deprecated)]
             let prim = indices.to_primitive();
@@ -86,7 +92,7 @@ fn take_map(bencher: Bencher, (patches_sparsity, index_multiple): (f64, f64)) {
     );
 
     bencher
-        .with_inputs(|| (&patches, &indices, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&patches, &indices, SESSION.create_execution_ctx()))
         .bench_refs(|(patches, indices, ctx)| {
             #[expect(deprecated)]
             let prim = indices.to_primitive();
diff --git a/vortex-array/benches/take_primitive.rs b/vortex-array/benches/take_primitive.rs
index 4411cf1ac79..e211e54d5f7 100644
--- a/vortex-array/benches/take_primitive.rs
+++ b/vortex-array/benches/take_primitive.rs
@@ -8,16 +8,19 @@
 #![expect(clippy::cast_possible_truncation)]
 #![expect(clippy::unwrap_used)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use rand::distr::Uniform;
 use rand::prelude::*;
 use rand_distr::Zipf;
 use vortex_array::Canonical;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::DictArray;
 use vortex_array::arrays::PrimitiveArray;
+use vortex_array::session::ArraySession;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
@@ -29,6 +32,9 @@ const NUM_INDICES: &[usize] = &[1_000, 10_000, 100_000];
 /// Size of the source vector / dictionary values.
 const VECTOR_SIZE: &[usize] = &[16, 256, 2048, 8192];
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 // --- DictArray canonicalization benchmarks ---
 
 #[divan::bench(args = NUM_INDICES, consts = VECTOR_SIZE, sample_count = 100_000)]
@@ -41,12 +47,9 @@ fn dict_canonicalize_uniform<const NUM_VALUES: usize>(bencher: Bencher, num_indi
 
     let dict = DictArray::try_new(codes.into_array(), values.into_array()).unwrap();
 
-    bencher.with_inputs(|| &dict).bench_refs(|dict| {
-        (*dict)
-            .clone()
-            .into_array()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
-    });
+    bencher
+        .with_inputs(|| (&dict, SESSION.create_execution_ctx()))
+        .bench_refs(|(dict, ctx)| (*dict).clone().into_array().execute::<Canonical>(ctx));
 }
 
 #[divan::bench(args = NUM_INDICES, consts = VECTOR_SIZE, sample_count = 100_000)]
@@ -63,10 +66,7 @@ fn dict_canonicalize_zipfian<const NUM_VALUES: usize>(bencher: Bencher, num_indi
 
     let dict = DictArray::try_new(codes.into_array(), values.into_array()).unwrap();
 
-    bencher.with_inputs(|| &dict).bench_refs(|dict| {
-        (*dict)
-            .clone()
-            .into_array()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
-    });
+    bencher
+        .with_inputs(|| (&dict, SESSION.create_execution_ctx()))
+        .bench_refs(|(dict, ctx)| (*dict).clone().into_array().execute::<Canonical>(ctx));
 }
diff --git a/vortex-array/benches/take_struct.rs b/vortex-array/benches/take_struct.rs
index 6346bb705ac..5f15894383a 100644
--- a/vortex-array/benches/take_struct.rs
+++ b/vortex-array/benches/take_struct.rs
@@ -3,24 +3,30 @@
 
 #![expect(clippy::unwrap_used)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use rand::RngExt;
 use rand::SeedableRng;
 use rand::distr::Uniform;
 use rand::rngs::StdRng;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::RecursiveCanonical;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::StructArray;
 use vortex_array::dtype::FieldNames;
+use vortex_array::session::ArraySession;
 use vortex_array::validity::Validity;
 use vortex_buffer::Buffer;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
 }
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 const ARRAY_SIZE: usize = 100_000;
 const TAKE_SIZE: usize = 1000;
 
@@ -54,7 +60,7 @@ fn take_struct_simple(bencher: Bencher) {
             (
                 &struct_array,
                 &indices_array,
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(array, indices, ctx)| {
@@ -97,7 +103,7 @@ fn take_struct_wide(bencher: Bencher, width: usize) {
             (
                 &struct_array,
                 &indices_array,
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(array, indices, ctx)| {
@@ -137,7 +143,7 @@ fn take_struct_sequential_indices(bencher: Bencher) {
             (
                 &struct_array,
                 &indices_array,
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(array, indices, ctx)| {
diff --git a/vortex-array/benches/to_arrow.rs b/vortex-array/benches/to_arrow.rs
index 332d0b642c0..0f84feb7baa 100644
--- a/vortex-array/benches/to_arrow.rs
+++ b/vortex-array/benches/to_arrow.rs
@@ -4,11 +4,11 @@
 #![expect(clippy::unwrap_used)]
 
 use std::sync::Arc;
+use std::sync::LazyLock;
 
 use divan::Bencher;
 use vortex_array::ArrayRef;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::DecimalArray;
 use vortex_array::arrays::ListArray;
@@ -25,11 +25,16 @@ use vortex_array::dtype::DecimalDType;
 use vortex_array::dtype::Nullability;
 use vortex_array::dtype::PType;
 use vortex_array::dtype::StructFields;
+use vortex_array::session::ArraySession;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
 }
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 fn schema() -> DType {
     let fields = StructFields::from_iter([
         (
@@ -87,22 +92,17 @@ fn to_arrow_dtype(bencher: Bencher) {
 #[divan::bench]
 fn ArrowExportVTable_to_arrow_field(bencher: Bencher) {
     // Warm the ArrowSession
-    drop(
-        LEGACY_SESSION
-            .arrow()
-            .to_arrow_field("", &schema())
-            .unwrap(),
-    );
+    drop(SESSION.arrow().to_arrow_field("", &schema()).unwrap());
 
     bencher
         .with_inputs(schema)
-        .bench_values(|dtype| LEGACY_SESSION.arrow().to_arrow_field("", &dtype).unwrap())
+        .bench_values(|dtype| SESSION.arrow().to_arrow_field("", &dtype).unwrap())
 }
 
 #[divan::bench]
 fn to_arrow_array(bencher: Bencher) {
     bencher
-        .with_inputs(|| (array(), LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (array(), SESSION.create_execution_ctx()))
         .bench_values(|(array, mut ctx)| {
             #[expect(deprecated, reason = "benchmarking deprecated code path")]
             array.execute_arrow(None, &mut ctx).unwrap()
@@ -113,16 +113,16 @@ fn to_arrow_array(bencher: Bencher) {
 #[divan::bench]
 fn ArrowExportVTable_execute_arrow(bencher: Bencher) {
     // Warm the ArrowSession
-    drop(LEGACY_SESSION.arrow().execute_arrow(
-        array(),
-        None,
-        &mut LEGACY_SESSION.create_execution_ctx(),
-    ));
+    drop(
+        SESSION
+            .arrow()
+            .execute_arrow(array(), None, &mut SESSION.create_execution_ctx()),
+    );
 
     bencher
-        .with_inputs(|| (array(), LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (array(), SESSION.create_execution_ctx()))
         .bench_values(|(array, mut ctx)| {
-            LEGACY_SESSION
+            SESSION
                 .arrow()
                 .execute_arrow(array, None, &mut ctx)
                 .unwrap()
diff --git a/vortex-array/benches/varbinview_zip.rs b/vortex-array/benches/varbinview_zip.rs
index b7283bd7c52..d18012d9914 100644
--- a/vortex-array/benches/varbinview_zip.rs
+++ b/vortex-array/benches/varbinview_zip.rs
@@ -3,21 +3,27 @@
 
 #![expect(clippy::unwrap_used)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::RecursiveCanonical;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::VarBinViewArray;
 use vortex_array::builtins::ArrayBuiltins;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
+use vortex_array::session::ArraySession;
 use vortex_mask::Mask;
+use vortex_session::VortexSession;
 
 fn main() {
     divan::main();
 }
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 /// Benchmarks zip on VarBinView arrays with a highly fragmented mask (worst case for per-slice lookup paths).
 #[divan::bench]
 fn varbinview_zip_fragmented_mask(bencher: Bencher) {
@@ -32,7 +38,7 @@ fn varbinview_zip_fragmented_mask(bencher: Bencher) {
                 if_true.clone(),
                 if_false.clone(),
                 mask.clone().into_array(),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(t, f, m, ctx)| {
@@ -57,7 +63,7 @@ fn varbinview_zip_block_mask(bencher: Bencher) {
                 if_true.clone(),
                 if_false.clone(),
                 mask.clone().into_array(),
-                LEGACY_SESSION.create_execution_ctx(),
+                SESSION.create_execution_ctx(),
             )
         })
         .bench_refs(|(t, f, m, ctx)| {
diff --git a/vortex-array/src/aggregate_fn/accumulator.rs b/vortex-array/src/aggregate_fn/accumulator.rs
index 762d5e00fb0..c89418e67a6 100644
--- a/vortex-array/src/aggregate_fn/accumulator.rs
+++ b/vortex-array/src/aggregate_fn/accumulator.rs
@@ -142,7 +142,6 @@ impl<V: AggregateFnVTable> DynAccumulator for Accumulator<V> {
         }
 
         let session = ctx.session().clone();
-        let kernels = &session.aggregate_fns().kernels;
 
         // 1. Kernel registry first: a registered `(encoding, aggregate_fn)` kernel is strictly
         //    more specific than the vtable's `try_accumulate` short-circuit. Checking the
@@ -150,13 +149,9 @@ impl<V: AggregateFnVTable> DynAccumulator for Accumulator<V> {
         //    `Combined::try_accumulate` always returns true, so a later kernel check would be
         //    unreachable.
         {
-            let kernels_r = kernels.read();
-            let batch_id = batch.encoding_id();
-            let kernel = kernels_r
-                .get(&(batch_id, Some(self.aggregate_fn.id())))
-                .or_else(|| kernels_r.get(&(batch_id, None)))
-                .copied();
-            drop(kernels_r);
+            let kernel = session
+                .aggregate_fns()
+                .find_aggregate_kernel(batch.encoding_id(), self.aggregate_fn.id());
             if let Some(kernel) = kernel
                 && let Some(result) = kernel.aggregate(&self.aggregate_fn, batch, ctx)?
             {
@@ -187,14 +182,9 @@ impl<V: AggregateFnVTable> DynAccumulator for Accumulator<V> {
                 break;
             }
 
-            let kernels_r = kernels.read();
-            let batch_id = batch.encoding_id();
-            let kernel = kernels_r
-                .get(&(batch_id, Some(self.aggregate_fn.id())))
-                .or_else(|| kernels_r.get(&(batch_id, None)))
-                .copied();
-            drop(kernels_r);
-            if let Some(kernel) = kernel
+            if let Some(kernel) = session
+                .aggregate_fns()
+                .find_aggregate_kernel(batch.encoding_id(), self.aggregate_fn.id())
                 && let Some(result) = kernel.aggregate(&self.aggregate_fn, &batch, ctx)?
             {
                 vortex_ensure!(
diff --git a/vortex-array/src/aggregate_fn/accumulator_grouped.rs b/vortex-array/src/aggregate_fn/accumulator_grouped.rs
index a751a7c5749..b87c04ee204 100644
--- a/vortex-array/src/aggregate_fn/accumulator_grouped.rs
+++ b/vortex-array/src/aggregate_fn/accumulator_grouped.rs
@@ -11,7 +11,6 @@ use vortex_error::vortex_err;
 use vortex_error::vortex_panic;
 use vortex_mask::Mask;
 
-use crate::AnyCanonical;
 use crate::ArrayRef;
 use crate::Canonical;
 use crate::Columnar;
@@ -30,14 +29,152 @@ use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
 use crate::arrays::listview::ListViewArrayExt;
 use crate::builders::builder_with_capacity;
 use crate::builtins::ArrayBuiltins;
+use crate::columnar::AnyColumnar;
 use crate::dtype::DType;
-use crate::dtype::IntegerPType;
 use crate::executor::max_iterations;
 use crate::match_each_integer_ptype;
 
 /// Reference-counted type-erased grouped accumulator.
 pub type GroupedAccumulatorRef = Box<dyn DynGroupedAccumulator>;
 
+/// A batch of grouped values to aggregate.
+///
+/// Each outer list value is one group, and the inner element array is shared by all groups.
+/// Aggregate implementations can inspect the concrete grouped representation directly, or ask for
+/// derived ranges when their algorithm is expressed in terms of `(offset, size)` pairs.
+pub enum GroupedArray {
+    /// Groups represented as a list-view array with per-group offsets and sizes.
+    ListView(ListViewArray),
+    /// Groups represented as a fixed-size list array.
+    FixedSizeList(FixedSizeListArray),
+}
+
+impl From<ListViewArray> for GroupedArray {
+    fn from(groups: ListViewArray) -> Self {
+        Self::ListView(groups)
+    }
+}
+
+impl From<FixedSizeListArray> for GroupedArray {
+    fn from(groups: FixedSizeListArray) -> Self {
+        Self::FixedSizeList(groups)
+    }
+}
+
+impl GroupedArray {
+    /// The inner element array shared by all groups.
+    pub fn elements(&self) -> &ArrayRef {
+        match self {
+            Self::ListView(groups) => groups.elements(),
+            Self::FixedSizeList(groups) => groups.elements(),
+        }
+    }
+
+    /// Return the `(offset, size)` ranges describing each group in `elements`.
+    pub fn group_ranges(&self, ctx: &mut ExecutionCtx) -> VortexResult<GroupRanges> {
+        match self {
+            Self::ListView(groups) => list_view_group_ranges(groups, ctx),
+            Self::FixedSizeList(groups) => Ok(fixed_size_list_group_ranges(groups)),
+        }
+    }
+
+    /// Return the per-group validity mask.
+    pub fn group_validity(&self, ctx: &mut ExecutionCtx) -> VortexResult<Mask> {
+        match self {
+            Self::ListView(groups) => groups.validity()?.execute_mask(groups.len(), ctx),
+            Self::FixedSizeList(groups) => groups.validity()?.execute_mask(groups.len(), ctx),
+        }
+    }
+
+    /// The number of groups in this batch.
+    pub fn len(&self) -> usize {
+        match self {
+            Self::ListView(groups) => groups.len(),
+            Self::FixedSizeList(groups) => groups.len(),
+        }
+    }
+
+    /// Returns true when this batch contains no groups.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Returns true when every group is valid.
+    pub fn all_groups_valid(&self, ctx: &mut ExecutionCtx) -> VortexResult<bool> {
+        Ok(self.group_validity(ctx)?.all_true())
+    }
+
+    unsafe fn with_elements_unchecked(&self, elements: ArrayRef) -> VortexResult<Self> {
+        Ok(match self {
+            Self::ListView(groups) => unsafe {
+                ListViewArray::new_unchecked(
+                    elements,
+                    groups.offsets().clone(),
+                    groups.sizes().clone(),
+                    groups.validity()?,
+                )
+            }
+            .into(),
+            Self::FixedSizeList(groups) => unsafe {
+                FixedSizeListArray::new_unchecked(
+                    elements,
+                    groups.list_size(),
+                    groups.validity()?,
+                    groups.len(),
+                )
+            }
+            .into(),
+        })
+    }
+}
+
+/// The physical ranges of a grouped array.
+pub enum GroupRanges {
+    /// Explicit ranges extracted from a list-view array.
+    ListView {
+        /// The `(offset, size)` ranges.
+        ranges: Vec<(usize, usize)>,
+    },
+    /// Uniform ranges derived from a fixed-size list array.
+    FixedSizeList {
+        /// The number of groups.
+        len: usize,
+        /// The number of elements in each group.
+        size: usize,
+    },
+}
+
+impl GroupRanges {
+    /// The number of groups described by these ranges.
+    pub fn len(&self) -> usize {
+        match self {
+            Self::ListView { ranges } => ranges.len(),
+            Self::FixedSizeList { len, .. } => *len,
+        }
+    }
+
+    /// Returns true when there are no groups.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Return the `(offset, size)` range for the group at `index`.
+    fn range(&self, index: usize) -> (usize, usize) {
+        match self {
+            Self::ListView { ranges } => ranges[index],
+            Self::FixedSizeList { len, size } => {
+                assert!(index < *len, "range index out of bounds");
+                (index * size, *size)
+            }
+        }
+    }
+
+    /// Iterate over all `(offset, size)` group ranges.
+    pub fn iter(&self) -> impl Iterator<Item = (usize, usize)> + '_ {
+        (0..self.len()).map(|index| self.range(index))
+    }
+}
+
 /// An accumulator used for computing grouped aggregates.
 ///
 /// Note that the groups must be processed in order, and the accumulator does not support random
@@ -128,8 +265,8 @@ impl<V: AggregateFnVTable> DynGroupedAccumulator for GroupedAccumulator<V> {
             Columnar::Constant(c) => c.into_array().execute::<Canonical>(ctx)?,
         };
         match canonical {
-            Canonical::List(groups) => self.accumulate_list_view(&groups, ctx),
-            Canonical::FixedSizeList(groups) => self.accumulate_fixed_size_list(&groups, ctx),
+            Canonical::List(groups) => self.accumulate_grouped_array(groups.into(), ctx),
+            Canonical::FixedSizeList(groups) => self.accumulate_grouped_array(groups.into(), ctx),
             _ => vortex_panic!("We checked the DType above, so this should never happen"),
         }
     }
@@ -155,167 +292,83 @@ impl<V: AggregateFnVTable> DynGroupedAccumulator for GroupedAccumulator<V> {
 }
 
 impl<V: AggregateFnVTable> GroupedAccumulator<V> {
-    fn accumulate_list_view(
+    fn accumulate_grouped_array(
         &mut self,
-        groups: &ListViewArray,
+        groups: GroupedArray,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<()> {
         let mut elements = groups.elements().clone();
-        let groups_validity = groups.validity()?;
         let session = ctx.session().clone();
-        let kernels = &session.aggregate_fns().grouped_kernels;
 
         for _ in 0..max_iterations() {
-            if elements.is::<AnyCanonical>() {
-                break;
+            // Try a registered grouped kernel for the current element encoding.
+            if let Some(kernel) = session
+                .aggregate_fns()
+                .find_grouped_encoding_kernel(elements.encoding_id(), self.aggregate_fn.id())
+            {
+                // SAFETY: we assume that elements execution is safe
+                let kernel_groups = unsafe { groups.with_elements_unchecked(elements.clone())? };
+                if let Some(result) =
+                    kernel.grouped_aggregate(&self.aggregate_fn, &kernel_groups, ctx)?
+                {
+                    return self.push_result(result);
+                }
             }
 
-            let kernels_r = kernels.read();
-            if let Some(result) = kernels_r
-                .get(&(elements.encoding_id(), Some(self.aggregate_fn.id())))
-                .or_else(|| kernels_r.get(&(elements.encoding_id(), None)))
-                .and_then(|kernel| {
-                    // SAFETY: we assume that elements execution is safe
-                    let groups = unsafe {
-                        ListViewArray::new_unchecked(
-                            elements.clone(),
-                            groups.offsets().clone(),
-                            groups.sizes().clone(),
-                            groups_validity.clone(),
-                        )
-                    };
-                    kernel
-                        .grouped_aggregate(&self.aggregate_fn, &groups)
-                        .transpose()
-                })
-                .transpose()?
+            // Try a grouped kernel for the current aggregate regardless of element encoding.
+            if let Some(kernel) = session
+                .aggregate_fns()
+                .find_grouped_kernel(self.aggregate_fn.id())
             {
-                return self.push_result(result);
+                // SAFETY: we preserve the grouped shape and validity while replacing the
+                // elements with another representation of the same logical array.
+                let kernel_groups = unsafe { groups.with_elements_unchecked(elements.clone())? };
+                if let Some(result) =
+                    kernel.grouped_aggregate(&self.aggregate_fn, &kernel_groups, ctx)?
+                {
+                    return self.push_result(result);
+                }
+            }
+
+            if elements.is::<AnyColumnar>() {
+                break;
             }
 
             // Execute one step and try again
             elements = elements.execute(ctx)?;
         }
 
-        // Otherwise, we iterate the offsets and sizes and accumulate each group one by one.
         let elements = elements.execute::<Columnar>(ctx)?.into_array();
-        let offsets = groups.offsets();
-        let sizes = groups.sizes().cast(offsets.dtype().clone())?;
-        let validity = groups_validity.execute_mask(offsets.len(), ctx)?;
-
-        match_each_integer_ptype!(offsets.dtype().as_ptype(), |O| {
-            let offsets = offsets.clone().execute::<Buffer<O>>(ctx)?;
-            let sizes = sizes.execute::<Buffer<O>>(ctx)?;
-            self.accumulate_list_view_typed(
-                &elements,
-                offsets.as_ref(),
-                sizes.as_ref(),
-                &validity,
-                ctx,
-            )
-        })
-    }
-
-    fn accumulate_list_view_typed<O: IntegerPType>(
-        &mut self,
-        elements: &ArrayRef,
-        offsets: &[O],
-        sizes: &[O],
-        validity: &Mask,
-        ctx: &mut ExecutionCtx,
-    ) -> VortexResult<()> {
-        let mut accumulator = Accumulator::try_new(
-            self.vtable.clone(),
-            self.options.clone(),
-            self.dtype.clone(),
-        )?;
-        let mut states = builder_with_capacity(&self.partial_dtype, offsets.len());
-
-        for (offset, size) in offsets.iter().zip(sizes.iter()) {
-            let offset = offset.to_usize().vortex_expect("Offset value is not usize");
-            let size = size.to_usize().vortex_expect("Size value is not usize");
-
-            if validity.value(offset) {
-                let group = elements.slice(offset..offset + size)?;
-                accumulator.accumulate(&group, ctx)?;
-                states.append_scalar(&accumulator.flush()?)?;
-            } else {
-                states.append_null()
-            }
-        }
+        // SAFETY: we preserve the grouped shape and validity while replacing the elements with an
+        // executed form of the same logical array.
+        let grouped = unsafe { groups.with_elements_unchecked(elements)? };
 
-        self.push_result(states.finish())
+        // Otherwise, we iterate the offsets and sizes and accumulate each group one by one.
+        self.accumulate_grouped_fallback(&grouped, ctx)
     }
 
-    fn accumulate_fixed_size_list(
+    fn accumulate_grouped_fallback(
         &mut self,
-        groups: &FixedSizeListArray,
+        grouped: &GroupedArray,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<()> {
-        let mut elements = groups.elements().clone();
-        let groups_validity = groups.validity()?;
-        let session = ctx.session().clone();
-        let kernels = &session.aggregate_fns().grouped_kernels;
-
-        for _ in 0..64 {
-            if elements.is::<AnyCanonical>() {
-                break;
-            }
-
-            let kernels_r = kernels.read();
-            if let Some(result) = kernels_r
-                .get(&(elements.encoding_id(), Some(self.aggregate_fn.id())))
-                .or_else(|| kernels_r.get(&(elements.encoding_id(), None)))
-                .and_then(|kernel| {
-                    // SAFETY: we assume that elements execution is safe
-                    let groups = unsafe {
-                        FixedSizeListArray::new_unchecked(
-                            elements.clone(),
-                            groups.list_size(),
-                            groups_validity.clone(),
-                            groups.len(),
-                        )
-                    };
-
-                    kernel
-                        .grouped_aggregate_fixed_size(&self.aggregate_fn, &groups)
-                        .transpose()
-                })
-                .transpose()?
-            {
-                return self.push_result(result);
-            }
-
-            // Execute one step and try again
-            elements = elements.execute(ctx)?;
-        }
-
-        // Otherwise, we iterate the offsets and sizes and accumulate each group one by one.
-        let elements = elements.execute::<Columnar>(ctx)?.into_array();
-        let validity = groups_validity.execute_mask(groups.len(), ctx)?;
-
         let mut accumulator = Accumulator::try_new(
             self.vtable.clone(),
             self.options.clone(),
             self.dtype.clone(),
         )?;
-        let mut states = builder_with_capacity(&self.partial_dtype, groups.len());
+        let mut states = builder_with_capacity(&self.partial_dtype, grouped.len());
+        let group_ranges = grouped.group_ranges(ctx)?;
+        let group_validity = grouped.group_validity(ctx)?;
 
-        let mut offset = 0;
-        let size = groups
-            .list_size()
-            .to_usize()
-            .vortex_expect("List size is not usize");
-
-        for i in 0..groups.len() {
-            if validity.value(i) {
-                let group = elements.slice(offset..offset + size)?;
+        for ((offset, size), valid) in group_ranges.iter().zip(group_validity.iter()) {
+            if valid {
+                let group = grouped.elements().slice(offset..offset + size)?;
                 accumulator.accumulate(&group, ctx)?;
                 states.append_scalar(&accumulator.flush()?)?;
             } else {
                 states.append_null()
             }
-            offset += size;
         }
 
         self.push_result(states.finish())
@@ -332,3 +385,35 @@ impl<V: AggregateFnVTable> GroupedAccumulator<V> {
         Ok(())
     }
 }
+fn list_view_group_ranges(
+    groups: &ListViewArray,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<GroupRanges> {
+    let offsets = groups.offsets();
+    let sizes = groups.sizes().cast(offsets.dtype().clone())?;
+
+    let ranges = match_each_integer_ptype!(offsets.dtype().as_ptype(), |O| {
+        let offsets = offsets.clone().execute::<Buffer<O>>(ctx)?;
+        let sizes = sizes.execute::<Buffer<O>>(ctx)?;
+        offsets
+            .as_ref()
+            .iter()
+            .zip(sizes.as_ref().iter())
+            .map(|(offset, size)| {
+                (
+                    offset.to_usize().vortex_expect("Offset value is not usize"),
+                    size.to_usize().vortex_expect("Size value is not usize"),
+                )
+            })
+            .collect::<Vec<_>>()
+    });
+
+    Ok(GroupRanges::ListView { ranges })
+}
+
+fn fixed_size_list_group_ranges(groups: &FixedSizeListArray) -> GroupRanges {
+    GroupRanges::FixedSizeList {
+        len: groups.len(),
+        size: groups.list_size() as usize,
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/fns/all_non_distinct/bool.rs b/vortex-array/src/aggregate_fn/fns/all_non_distinct/bool.rs
index c06d335e458..f201653b815 100644
--- a/vortex-array/src/aggregate_fn/fns/all_non_distinct/bool.rs
+++ b/vortex-array/src/aggregate_fn/fns/all_non_distinct/bool.rs
@@ -10,5 +10,5 @@ where
     L: BoolArrayExt,
     R: BoolArrayExt,
 {
-    Ok(lhs.to_bit_buffer() == rhs.to_bit_buffer())
+    Ok(lhs.bit_buffer_view() == rhs.bit_buffer_view())
 }
diff --git a/vortex-array/src/aggregate_fn/fns/all_non_distinct/filter.rs b/vortex-array/src/aggregate_fn/fns/all_non_distinct/filter.rs
index 9ad4ea2cc30..b9aacd56163 100644
--- a/vortex-array/src/aggregate_fn/fns/all_non_distinct/filter.rs
+++ b/vortex-array/src/aggregate_fn/fns/all_non_distinct/filter.rs
@@ -14,7 +14,7 @@ pub(super) fn shared_validity_mask(
 ) -> VortexResult<Option<Mask>> {
     let lhs_validity = lhs.validity()?;
     let rhs_validity = rhs.validity()?;
-    if lhs_validity.no_nulls() && rhs_validity.no_nulls() {
+    if lhs_validity.definitely_no_nulls() && rhs_validity.definitely_no_nulls() {
         return Ok(Some(Mask::new_true(lhs.len())));
     }
 
@@ -33,7 +33,7 @@ pub(super) fn filter_valid_rows_if_needed(
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<Option<(ArrayRef, ArrayRef)>> {
     let validity = lhs.validity()?;
-    if validity.no_nulls() {
+    if validity.definitely_no_nulls() {
         return Ok(None);
     }
 
diff --git a/vortex-array/src/aggregate_fn/fns/all_non_distinct/list.rs b/vortex-array/src/aggregate_fn/fns/all_non_distinct/list.rs
index 9aa5e93d08c..2f4e3e52d91 100644
--- a/vortex-array/src/aggregate_fn/fns/all_non_distinct/list.rs
+++ b/vortex-array/src/aggregate_fn/fns/all_non_distinct/list.rs
@@ -28,8 +28,8 @@ pub(super) fn check_list_identical(
         return check_zero_copy_list_identical(lhs, rhs, ctx);
     }
 
-    let lhs = list_from_list_view(lhs.clone())?;
-    let rhs = list_from_list_view(rhs.clone())?;
+    let lhs = list_from_list_view(lhs.clone(), ctx)?;
+    let rhs = list_from_list_view(rhs.clone(), ctx)?;
 
     if !check_list_offsets_identical(&lhs, &rhs)? {
         return Ok(false);
diff --git a/vortex-array/src/aggregate_fn/fns/count/grouped.rs b/vortex-array/src/aggregate_fn/fns/count/grouped.rs
new file mode 100644
index 00000000000..fb94489dde0
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/count/grouped.rs
@@ -0,0 +1,216 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_buffer::Buffer;
+use vortex_error::VortexResult;
+use vortex_mask::Mask;
+
+use super::Count;
+use crate::ArrayRef;
+use crate::ExecutionCtx;
+use crate::IntoArray;
+use crate::aggregate_fn::AggregateFnRef;
+use crate::aggregate_fn::GroupRanges;
+use crate::aggregate_fn::GroupedArray;
+use crate::aggregate_fn::kernels::DynGroupedAggregateKernel;
+use crate::arrays::PrimitiveArray;
+use crate::validity::Validity;
+
+/// Encoding-independent grouped [`Count`] kernel.
+#[derive(Debug)]
+pub(crate) struct CountGroupedKernel;
+
+impl DynGroupedAggregateKernel for CountGroupedKernel {
+    fn grouped_aggregate(
+        &self,
+        aggregate_fn: &AggregateFnRef,
+        groups: &GroupedArray,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        if !aggregate_fn.is::<Count>() {
+            return Ok(None);
+        }
+        try_grouped_count(groups, ctx)
+    }
+}
+
+/// Count each valid group from the element validity mask.
+///
+/// The [`Count`] partial dtype is non-nullable `U64`, so a null outer group cannot be represented
+/// as a partial state. If any outer group is invalid, this returns `Ok(None)` and lets the caller
+/// use the existing fallback behavior.
+pub(super) fn try_grouped_count(
+    groups: &GroupedArray,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<Option<ArrayRef>> {
+    if !groups.all_groups_valid(ctx)? {
+        return Ok(None);
+    }
+    let group_ranges = groups.group_ranges(ctx)?;
+
+    Ok(Some(grouped_count(groups.elements(), &group_ranges, ctx)?))
+}
+
+/// Count the valid elements of each group described by `group_ranges` (element `(offset, size)`
+/// pairs) into a non-nullable `U64` array, one entry per group.
+fn grouped_count(
+    elements: &ArrayRef,
+    group_ranges: &GroupRanges,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ArrayRef> {
+    let elem_mask = elements.validity()?.execute_mask(elements.len(), ctx)?;
+
+    let counts: Buffer<u64> = if elem_mask.all_true() {
+        group_ranges.iter().map(|(_, size)| size as u64).collect()
+    } else {
+        group_ranges
+            .iter()
+            .map(|(offset, size)| valid_count(&elem_mask, offset, size) as u64)
+            .collect()
+    };
+
+    Ok(PrimitiveArray::new(counts, Validity::NonNullable).into_array())
+}
+
+/// Number of valid elements in the `[offset, offset + size)` range of the element mask.
+fn valid_count(elem_mask: &Mask, offset: usize, size: usize) -> usize {
+    elem_mask.slice(offset..offset + size).true_count()
+}
+
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::cast_possible_truncation)]
+
+    use vortex_buffer::Buffer;
+    use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
+
+    use crate::ArrayRef;
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::aggregate_fn::DynGroupedAccumulator;
+    use crate::aggregate_fn::EmptyOptions;
+    use crate::aggregate_fn::GroupedAccumulator;
+    use crate::aggregate_fn::fns::count::Count;
+    use crate::arrays::FixedSizeListArray;
+    use crate::arrays::ListViewArray;
+    use crate::arrays::PrimitiveArray;
+    use crate::arrays::VarBinViewArray;
+    use crate::assert_arrays_eq;
+    use crate::dtype::DType;
+    use crate::dtype::Nullability::NonNullable;
+    use crate::dtype::Nullability::Nullable;
+    use crate::dtype::PType;
+    use crate::validity::Validity;
+
+    /// Run a grouped count through the accumulator.
+    fn grouped_count_actual(groups: &ArrayRef, elem_dtype: &DType) -> VortexResult<ArrayRef> {
+        let mut acc = GroupedAccumulator::try_new(Count, EmptyOptions, elem_dtype.clone())?;
+        acc.accumulate_list(groups, &mut LEGACY_SESSION.create_execution_ctx())?;
+        acc.finish()
+    }
+
+    /// Reference valid-counts (non-nullable `U64`), one per group.
+    fn grouped_count_reference(
+        elements: &ArrayRef,
+        ranges: &[(usize, usize)],
+    ) -> VortexResult<ArrayRef> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let counts: Buffer<u64> = ranges
+            .iter()
+            .map(|&(offset, size)| {
+                Ok(elements
+                    .slice(offset..offset + size)?
+                    .valid_count(&mut ctx)? as u64)
+            })
+            .collect::<VortexResult<_>>()?;
+        Ok(PrimitiveArray::new(counts, Validity::NonNullable).into_array())
+    }
+
+    fn listview(elements: ArrayRef, ranges: &[(usize, usize)]) -> VortexResult<ArrayRef> {
+        let offsets = PrimitiveArray::from_iter(ranges.iter().map(|&(o, _)| o as i32));
+        let sizes = PrimitiveArray::from_iter(ranges.iter().map(|&(_, s)| s as i32));
+        Ok(ListViewArray::try_new(
+            elements,
+            offsets.into_array(),
+            sizes.into_array(),
+            Validity::NonNullable,
+        )?
+        .into_array())
+    }
+
+    #[test]
+    fn listview_counts_all_valid() -> VortexResult<()> {
+        let elements =
+            PrimitiveArray::new(buffer![1i32, 2, 3, 4, 5, 6], Validity::NonNullable).into_array();
+        let elem_dtype = DType::Primitive(PType::I32, NonNullable);
+        let ranges = [(0, 2), (2, 1), (3, 3), (6, 0)];
+
+        let groups = listview(elements.clone(), &ranges)?;
+        let actual = grouped_count_actual(&groups, &elem_dtype)?;
+        let expected = grouped_count_reference(&elements, &ranges)?;
+
+        let direct =
+            PrimitiveArray::new(buffer![2u64, 1, 3, 0], Validity::NonNullable).into_array();
+        assert_arrays_eq!(&actual, &direct);
+        assert_arrays_eq!(&actual, &expected);
+        Ok(())
+    }
+
+    #[test]
+    fn listview_counts_with_nulls() -> VortexResult<()> {
+        let elements =
+            PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), None, None, Some(9)])
+                .into_array();
+        let elem_dtype = DType::Primitive(PType::I32, Nullable);
+        let ranges = [(0, 3), (3, 2), (5, 1)];
+
+        let groups = listview(elements.clone(), &ranges)?;
+        let actual = grouped_count_actual(&groups, &elem_dtype)?;
+        let expected = grouped_count_reference(&elements, &ranges)?;
+
+        // Group 0: {1, null, 3} -> 2. Group 1: {null, null} -> 0. Group 2: {9} -> 1.
+        let direct = PrimitiveArray::new(buffer![2u64, 0, 1], Validity::NonNullable).into_array();
+        assert_arrays_eq!(&actual, &direct);
+        assert_arrays_eq!(&actual, &expected);
+        Ok(())
+    }
+
+    #[test]
+    fn listview_counts_varbinview_with_nulls() -> VortexResult<()> {
+        let elements = VarBinViewArray::from_iter_nullable_str([
+            Some("a"),
+            None,
+            Some("bbb"),
+            None,
+            Some("cc"),
+        ])
+        .into_array();
+        let elem_dtype = elements.dtype().clone();
+        let ranges = [(0, 2), (2, 2), (4, 1)];
+
+        let groups = listview(elements.clone(), &ranges)?;
+        let actual = grouped_count_actual(&groups, &elem_dtype)?;
+        let expected = grouped_count_reference(&elements, &ranges)?;
+
+        let direct = PrimitiveArray::new(buffer![1u64, 1, 1], Validity::NonNullable).into_array();
+        assert_arrays_eq!(&actual, &direct);
+        assert_arrays_eq!(&actual, &expected);
+        Ok(())
+    }
+
+    #[test]
+    fn fixed_size_counts_with_nulls() -> VortexResult<()> {
+        let elements =
+            PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), Some(4)]).into_array();
+        let elem_dtype = DType::Primitive(PType::I32, Nullable);
+        let groups =
+            FixedSizeListArray::try_new(elements, 2, Validity::NonNullable, 2)?.into_array();
+
+        let actual = grouped_count_actual(&groups, &elem_dtype)?;
+        let direct = PrimitiveArray::new(buffer![1u64, 2], Validity::NonNullable).into_array();
+        assert_arrays_eq!(&actual, &direct);
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/fns/count/mod.rs b/vortex-array/src/aggregate_fn/fns/count/mod.rs
index e25c42e0845..1fe984fb099 100644
--- a/vortex-array/src/aggregate_fn/fns/count/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/count/mod.rs
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+mod grouped;
+pub(crate) use grouped::CountGroupedKernel;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
diff --git a/vortex-array/src/aggregate_fn/fns/is_constant/bool.rs b/vortex-array/src/aggregate_fn/fns/is_constant/bool.rs
index c63025ccd7c..967f19058b6 100644
--- a/vortex-array/src/aggregate_fn/fns/is_constant/bool.rs
+++ b/vortex-array/src/aggregate_fn/fns/is_constant/bool.rs
@@ -5,6 +5,6 @@ use crate::arrays::BoolArray;
 use crate::arrays::bool::BoolArrayExt;
 
 pub(super) fn check_bool_constant(array: &BoolArray) -> bool {
-    let true_count = array.to_bit_buffer().true_count();
+    let true_count = array.bit_buffer_view().true_count();
     true_count == array.len() || true_count == 0
 }
diff --git a/vortex-array/src/aggregate_fn/fns/is_sorted/bool.rs b/vortex-array/src/aggregate_fn/fns/is_sorted/bool.rs
index afd18f15902..69c0aaf6692 100644
--- a/vortex-array/src/aggregate_fn/fns/is_sorted/bool.rs
+++ b/vortex-array/src/aggregate_fn/fns/is_sorted/bool.rs
@@ -21,7 +21,7 @@ pub(super) fn check_bool_sorted(
     {
         Mask::AllFalse(_) => Ok(!strict),
         Mask::AllTrue(_) => {
-            let values = array.to_bit_buffer();
+            let values = array.bit_buffer_view();
             Ok(if strict {
                 values.iter().is_strict_sorted()
             } else {
@@ -31,7 +31,7 @@ pub(super) fn check_bool_sorted(
         Mask::Values(mask_values) => {
             if strict {
                 let validity_buffer = mask_values.bit_buffer();
-                let values = array.to_bit_buffer();
+                let values = array.bit_buffer_view();
                 Ok(validity_buffer
                     .iter()
                     .zip(values.iter())
@@ -39,7 +39,7 @@ pub(super) fn check_bool_sorted(
                     .is_strict_sorted())
             } else {
                 let set_indices = mask_values.bit_buffer().set_indices();
-                let values = array.to_bit_buffer();
+                let values = array.bit_buffer_view();
                 let values_iter = set_indices.map(|idx|
                     // Safety:
                     // All idxs are in-bounds for the array.
diff --git a/vortex-array/src/aggregate_fn/fns/mean/mod.rs b/vortex-array/src/aggregate_fn/fns/mean/mod.rs
index f7d471023ee..17fb2616d44 100644
--- a/vortex-array/src/aggregate_fn/fns/mean/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/mean/mod.rs
@@ -104,7 +104,9 @@ impl BinaryCombined for Mean {
         let sum = sum_cast.as_primitive().typed_value::<f64>();
         let count = count_cast.as_primitive().typed_value::<f64>();
         let value = match (sum, count) {
-            (None, _) | (_, None) | (_, Some(0.0)) => return Ok(Scalar::null(target)), // Sum overflowed
+            (None, _) | (_, None) => return Ok(Scalar::null(target)), // Sum overflowed
+            // A count of zero yields 0/0 = NaN, matching the array `finalize` path: nulls are
+            // skipped during accumulation, so an all-null input is an empty mean, not null.
             (Some(s), Some(c)) => s / c,
         };
         Ok(Scalar::primitive(value, Nullability::Nullable))
@@ -230,11 +232,11 @@ mod tests {
     }
 
     #[test]
-    fn mean_all_null_returns_null() -> VortexResult<()> {
+    fn mean_all_null_returns_nan() -> VortexResult<()> {
         let array = PrimitiveArray::from_option_iter::<f64, _>([None, None, None]).into_array();
         let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let result = mean(&array, &mut ctx)?;
-        assert_eq!(result.as_primitive().as_::<f64>(), None);
+        assert!(result.as_primitive().as_::<f64>().is_some_and(f64::is_nan));
         Ok(())
     }
 
diff --git a/vortex-array/src/aggregate_fn/fns/min_max/bool.rs b/vortex-array/src/aggregate_fn/fns/min_max/bool.rs
index 54501409fe5..adca6453862 100644
--- a/vortex-array/src/aggregate_fn/fns/min_max/bool.rs
+++ b/vortex-array/src/aggregate_fn/fns/min_max/bool.rs
@@ -25,7 +25,7 @@ pub(super) fn accumulate_bool(
         .execute_mask(array.as_ref().len(), ctx)?;
     let (true_count, valid_count) = match mask.bit_buffer() {
         AllOr::None => return Ok(()),
-        AllOr::All => (array.to_bit_buffer().true_count(), array.as_ref().len()),
+        AllOr::All => (array.bit_buffer_view().true_count(), array.as_ref().len()),
         AllOr::Some(validity) => (
             array.to_bit_buffer().bitand(validity).true_count(),
             validity.true_count(),
diff --git a/vortex-array/src/aggregate_fn/fns/min_max/mod.rs b/vortex-array/src/aggregate_fn/fns/min_max/mod.rs
index f91ae351392..540b5608e28 100644
--- a/vortex-array/src/aggregate_fn/fns/min_max/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/min_max/mod.rs
@@ -61,8 +61,8 @@ pub fn min_max(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Option<
         return Ok(None);
     }
 
-    // Short-circuit for unsupported dtypes.
-    if MinMax.return_dtype(&EmptyOptions, array.dtype()).is_none() {
+    // Short-circuit for dtypes this helper cannot currently compute.
+    if !minmax_compute_supported_dtype(array.dtype()) {
         return Ok(None);
     }
 
@@ -162,6 +162,37 @@ pub fn make_minmax_dtype(element_dtype: &DType) -> DType {
     )
 }
 
+fn minmax_supported_dtype(input_dtype: &DType) -> bool {
+    match input_dtype {
+        DType::Bool(_)
+        | DType::Primitive(..)
+        | DType::Decimal(..)
+        | DType::Utf8(..)
+        | DType::Binary(..)
+        | DType::Extension(..) => true,
+        DType::List(element_dtype, _) => minmax_supported_dtype(element_dtype),
+        DType::FixedSizeList(element_dtype, ..) => minmax_supported_dtype(element_dtype),
+        _ => false,
+    }
+}
+
+/// Returns whether [`min_max`] can currently compute extrema for this logical dtype.
+///
+/// This is intentionally narrower than [`minmax_supported_dtype`]. List and fixed-size-list
+/// extrema have a defined output dtype for aggregate expression lowering, but the accumulator does
+/// not yet implement lexicographic list comparison.
+fn minmax_compute_supported_dtype(input_dtype: &DType) -> bool {
+    matches!(
+        input_dtype,
+        DType::Bool(_)
+            | DType::Primitive(..)
+            | DType::Decimal(..)
+            | DType::Utf8(..)
+            | DType::Binary(..)
+            | DType::Extension(..)
+    )
+}
+
 impl AggregateFnVTable for MinMax {
     type Options = EmptyOptions;
     type Partial = MinMaxPartial;
@@ -175,15 +206,7 @@ impl AggregateFnVTable for MinMax {
     }
 
     fn return_dtype(&self, _options: &Self::Options, input_dtype: &DType) -> Option<DType> {
-        match input_dtype {
-            DType::Bool(_)
-            | DType::Primitive(..)
-            | DType::Decimal(..)
-            | DType::Utf8(..)
-            | DType::Binary(..)
-            | DType::Extension(..) => Some(make_minmax_dtype(input_dtype)),
-            _ => None,
-        }
+        minmax_supported_dtype(input_dtype).then(|| make_minmax_dtype(input_dtype))
     }
 
     fn partial_dtype(&self, options: &Self::Options, input_dtype: &DType) -> Option<DType> {
@@ -278,6 +301,8 @@ impl AggregateFnVTable for MinMax {
 
 #[cfg(test)]
 mod tests {
+    use std::sync::Arc;
+
     use vortex_buffer::BitBuffer;
     use vortex_buffer::buffer;
     use vortex_error::VortexExpect;
@@ -298,6 +323,8 @@ mod tests {
     use crate::arrays::ChunkedArray;
     use crate::arrays::ConstantArray;
     use crate::arrays::DecimalArray;
+    use crate::arrays::FixedSizeListArray;
+    use crate::arrays::ListArray;
     use crate::arrays::NullArray;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::VarBinArray;
@@ -570,6 +597,47 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn list_and_fixed_size_list_return_dtype() {
+        let element_dtype = DType::Primitive(PType::I32, Nullability::Nullable);
+        let list_dtype = DType::List(Arc::new(element_dtype.clone()), Nullability::Nullable);
+        let fixed_size_list_dtype =
+            DType::FixedSizeList(Arc::new(element_dtype), 1, Nullability::Nullable);
+
+        assert_eq!(
+            MinMax.return_dtype(&EmptyOptions, &list_dtype),
+            Some(make_minmax_dtype(&list_dtype))
+        );
+        assert_eq!(
+            MinMax.return_dtype(&EmptyOptions, &fixed_size_list_dtype),
+            Some(make_minmax_dtype(&fixed_size_list_dtype))
+        );
+    }
+
+    #[test]
+    fn list_and_fixed_size_list_min_max_returns_none() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+
+        let list_array = ListArray::try_new(
+            buffer![1i32, 2, 3].into_array(),
+            buffer![0u32, 2, 3].into_array(),
+            Validity::NonNullable,
+        )?
+        .into_array();
+        assert_eq!(min_max(&list_array, &mut ctx)?, None);
+
+        let fixed_size_list_array = FixedSizeListArray::try_new(
+            buffer![1i32, 2, 3, 4].into_array(),
+            2,
+            Validity::NonNullable,
+            2,
+        )?
+        .into_array();
+        assert_eq!(min_max(&fixed_size_list_array, &mut ctx)?, None);
+
+        Ok(())
+    }
+
     use crate::dtype::half::f16;
 
     #[test]
diff --git a/vortex-array/src/aggregate_fn/fns/sum/bool.rs b/vortex-array/src/aggregate_fn/fns/sum/bool.rs
index a32f3ba72f7..7728d3f64af 100644
--- a/vortex-array/src/aggregate_fn/fns/sum/bool.rs
+++ b/vortex-array/src/aggregate_fn/fns/sum/bool.rs
@@ -25,7 +25,7 @@ pub(super) fn accumulate_bool(
     let mask = b.as_ref().validity()?.execute_mask(b.as_ref().len(), ctx)?;
     let true_count = match mask.bit_buffer() {
         AllOr::None => return Ok(false),
-        AllOr::All => b.to_bit_buffer().true_count() as u64,
+        AllOr::All => b.bit_buffer_view().true_count() as u64,
         AllOr::Some(validity) => b.to_bit_buffer().bitand(validity).true_count() as u64,
     };
 
diff --git a/vortex-array/src/aggregate_fn/fns/sum/grouped.rs b/vortex-array/src/aggregate_fn/fns/sum/grouped.rs
new file mode 100644
index 00000000000..6f00cce7fdb
--- /dev/null
+++ b/vortex-array/src/aggregate_fn/fns/sum/grouped.rs
@@ -0,0 +1,367 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+use vortex_mask::AllOr;
+use vortex_mask::Mask;
+
+use super::Sum;
+use super::primitive::sum_float_all;
+use super::primitive::sum_signed_all;
+use super::primitive::sum_unsigned_all;
+use crate::ArrayRef;
+use crate::ExecutionCtx;
+use crate::IntoArray;
+use crate::aggregate_fn::AggregateFnRef;
+use crate::aggregate_fn::GroupRanges;
+use crate::aggregate_fn::GroupedArray;
+use crate::aggregate_fn::kernels::DynGroupedAggregateKernel;
+use crate::arrays::Primitive;
+use crate::arrays::PrimitiveArray;
+use crate::dtype::NativePType;
+use crate::match_each_native_ptype;
+
+/// Encoding-specific grouped [`Sum`] kernel for primitive element arrays.
+#[derive(Debug)]
+pub(crate) struct PrimitiveGroupedSumEncodingKernel;
+
+impl DynGroupedAggregateKernel for PrimitiveGroupedSumEncodingKernel {
+    fn grouped_aggregate(
+        &self,
+        aggregate_fn: &AggregateFnRef,
+        groups: &GroupedArray,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        if !aggregate_fn.is::<Sum>() {
+            return Ok(None);
+        }
+        try_grouped_sum(groups, ctx)
+    }
+}
+
+/// Grouped [`Sum`] implementation for canonical primitive elements.
+///
+/// Reuses the scalar primitive-sum reductions ([`sum_unsigned_all`]/[`sum_signed_all`]/
+/// [`sum_float_all`]) so the per-group semantics match scalar `sum` exactly (overflow saturates to
+/// a null sum, NaNs are skipped). The element validity mask is materialized once and sliced per
+/// group, rather than the per-group accumulator setup of the generic fallback path.
+pub(super) fn try_grouped_sum(
+    groups: &GroupedArray,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<Option<ArrayRef>> {
+    if !groups.elements().is::<Primitive>() {
+        return Ok(None);
+    }
+    let elements = groups.elements().clone().downcast::<Primitive>();
+    let group_ranges = groups.group_ranges(ctx)?;
+    let group_validity = groups.group_validity(ctx)?;
+
+    Ok(Some(grouped_sum(
+        &elements,
+        &group_ranges,
+        &group_validity,
+        ctx,
+    )?))
+}
+
+/// Sum each group described by `group_ranges` (element `(offset, size)` pairs), one sum per group.
+fn grouped_sum(
+    elements: &PrimitiveArray,
+    group_ranges: &GroupRanges,
+    group_validity: &Mask,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ArrayRef> {
+    let elem_mask = elements
+        .as_ref()
+        .validity()?
+        .execute_mask(elements.as_ref().len(), ctx)?;
+    let all_valid = matches!(elem_mask.slices(), AllOr::All);
+
+    let result = match_each_native_ptype!(elements.ptype(),
+        unsigned: |T| {
+            let values = elements.as_slice::<T>();
+            collect_sums::<T, u64>(values, group_ranges, group_validity, &elem_mask, all_valid,
+                sum_unsigned_all)
+        },
+        signed: |T| {
+            let values = elements.as_slice::<T>();
+            collect_sums::<T, i64>(values, group_ranges, group_validity, &elem_mask, all_valid,
+                sum_signed_all)
+        },
+        floating: |T| {
+            let values = elements.as_slice::<T>();
+            collect_sums::<T, f64>(values, group_ranges, group_validity, &elem_mask, all_valid,
+                |acc, slice| { sum_float_all(acc, slice); false })
+        }
+    );
+
+    Ok(result.into_array())
+}
+
+/// Reduce each group's element slice into a nullable sum. A group is null when the group
+/// itself is invalid, or when summing it overflows (`sum_run` returns `true`).
+fn collect_sums<T: NativePType, A: NativePType + Default>(
+    values: &[T],
+    group_ranges: &GroupRanges,
+    group_validity: &Mask,
+    elem_mask: &Mask,
+    all_valid: bool,
+    sum_run: impl Fn(&mut A, &[T]) -> bool,
+) -> PrimitiveArray {
+    let sums = group_ranges.iter().enumerate().map(|(i, (offset, size))| {
+        if !group_validity.value(i) {
+            return None;
+        }
+        let mut acc = A::default();
+        let overflow = if all_valid {
+            sum_run(&mut acc, &values[offset..offset + size])
+        } else {
+            sum_masked_group(&mut acc, values, offset, size, elem_mask, &sum_run)
+        };
+        (!overflow).then_some(acc)
+    });
+    PrimitiveArray::from_option_iter(sums)
+}
+
+/// Sum the valid elements of a single group, using the contiguous valid runs of the element mask
+/// intersected with the group's `[offset, offset + size)` range.
+fn sum_masked_group<T: NativePType, A>(
+    acc: &mut A,
+    values: &[T],
+    offset: usize,
+    size: usize,
+    elem_mask: &Mask,
+    sum_run: &impl Fn(&mut A, &[T]) -> bool,
+) -> bool {
+    match elem_mask.slice(offset..offset + size).slices() {
+        AllOr::All => sum_run(acc, &values[offset..offset + size]),
+        AllOr::None => false,
+        AllOr::Some(runs) => {
+            for &(start, end) in runs {
+                if sum_run(acc, &values[offset + start..offset + end]) {
+                    return true;
+                }
+            }
+            false
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::cast_possible_truncation)]
+
+    use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
+
+    use crate::ArrayRef;
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::aggregate_fn::DynGroupedAccumulator;
+    use crate::aggregate_fn::EmptyOptions;
+    use crate::aggregate_fn::GroupedAccumulator;
+    use crate::aggregate_fn::fns::sum::Sum;
+    use crate::aggregate_fn::fns::sum::sum;
+    use crate::arrays::FixedSizeListArray;
+    use crate::arrays::ListViewArray;
+    use crate::arrays::PrimitiveArray;
+    use crate::assert_arrays_eq;
+    use crate::builders::builder_with_capacity;
+    use crate::dtype::DType;
+    use crate::dtype::Nullability::NonNullable;
+    use crate::dtype::Nullability::Nullable;
+    use crate::dtype::PType;
+    use crate::validity::Validity;
+
+    /// Run a grouped sum through the accumulator.
+    fn grouped_sum_actual(groups: &ArrayRef, elem_dtype: &DType) -> VortexResult<ArrayRef> {
+        let mut acc = GroupedAccumulator::try_new(Sum, EmptyOptions, elem_dtype.clone())?;
+        acc.accumulate_list(groups, &mut LEGACY_SESSION.create_execution_ctx())?;
+        acc.finish()
+    }
+
+    /// Reference sums computed exactly like the generic slow path: per-group scalar [`sum`] for
+    /// valid groups, a null sum for invalid groups.
+    fn grouped_sum_reference(
+        elements: &ArrayRef,
+        ranges: &[(usize, usize)],
+        group_valid: &[bool],
+        elem_dtype: &DType,
+    ) -> VortexResult<ArrayRef> {
+        use crate::aggregate_fn::AggregateFnVTable;
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let sum_dtype = Sum
+            .partial_dtype(&EmptyOptions, elem_dtype)
+            .expect("sum partial dtype");
+        let mut builder = builder_with_capacity(&sum_dtype, ranges.len());
+        for (i, &(offset, size)) in ranges.iter().enumerate() {
+            if group_valid[i] {
+                let slice = elements.slice(offset..offset + size)?;
+                builder.append_scalar(&sum(&slice, &mut ctx)?)?;
+            } else {
+                builder.append_null();
+            }
+        }
+        Ok(builder.finish())
+    }
+
+    fn offsets_sizes(ranges: &[(usize, usize)]) -> (ArrayRef, ArrayRef) {
+        let offsets = PrimitiveArray::from_iter(ranges.iter().map(|&(o, _)| o as i32));
+        let sizes = PrimitiveArray::from_iter(ranges.iter().map(|&(_, s)| s as i32));
+        (offsets.into_array(), sizes.into_array())
+    }
+
+    fn listview(
+        elements: ArrayRef,
+        ranges: &[(usize, usize)],
+        group_valid: &[bool],
+    ) -> VortexResult<ArrayRef> {
+        let (offsets, sizes) = offsets_sizes(ranges);
+        let validity = if group_valid.iter().all(|&v| v) {
+            Validity::NonNullable
+        } else {
+            Validity::from_iter(group_valid.iter().copied())
+        };
+        Ok(ListViewArray::try_new(elements, offsets, sizes, validity)?.into_array())
+    }
+
+    #[test]
+    fn listview_matches_reference_unsigned() -> VortexResult<()> {
+        let elements =
+            PrimitiveArray::new(buffer![1u32, 2, 3, 4, 5, 6], Validity::NonNullable).into_array();
+        let elem_dtype = DType::Primitive(PType::U32, NonNullable);
+        let ranges = [(0, 2), (2, 1), (3, 3)];
+        let valid = [true, true, true];
+
+        let groups = listview(elements.clone(), &ranges, &valid)?;
+        let actual = grouped_sum_actual(&groups, &elem_dtype)?;
+        let expected = grouped_sum_reference(&elements, &ranges, &valid, &elem_dtype)?;
+
+        // Unsigned input sums to U64.
+        let direct = PrimitiveArray::from_option_iter([Some(3u64), Some(3u64), Some(15u64)]);
+        assert_arrays_eq!(&actual, &direct.into_array());
+        assert_arrays_eq!(&actual, &expected);
+        Ok(())
+    }
+
+    #[test]
+    fn listview_out_of_order_offsets_with_null_group() -> VortexResult<()> {
+        // Offsets are not in group order and a group is null: the group validity must be indexed by
+        // group index, not by element offset.
+        let elements =
+            PrimitiveArray::new(buffer![10i32, 20, 30, 40, 50, 60], Validity::NonNullable)
+                .into_array();
+        let elem_dtype = DType::Primitive(PType::I32, NonNullable);
+        let ranges = [(4, 2), (0, 2), (2, 2)];
+        let valid = [true, false, true];
+
+        let groups = listview(elements.clone(), &ranges, &valid)?;
+        let actual = grouped_sum_actual(&groups, &elem_dtype)?;
+        let expected = grouped_sum_reference(&elements, &ranges, &valid, &elem_dtype)?;
+
+        let direct = PrimitiveArray::from_option_iter([Some(110i64), None, Some(70i64)]);
+        assert_arrays_eq!(&actual, &direct.into_array());
+        assert_arrays_eq!(&actual, &expected);
+        Ok(())
+    }
+
+    #[test]
+    fn listview_interior_and_full_nulls() -> VortexResult<()> {
+        // Group 1 has an interior null, group 2 is entirely null, group 3 is empty.
+        let elements =
+            PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), None, None, Some(9)])
+                .into_array();
+        let elem_dtype = DType::Primitive(PType::I32, Nullable);
+        let ranges = [(0, 3), (3, 2), (5, 0), (5, 1)];
+        let valid = [true, true, true, true];
+
+        let groups = listview(elements.clone(), &ranges, &valid)?;
+        let actual = grouped_sum_actual(&groups, &elem_dtype)?;
+        let expected = grouped_sum_reference(&elements, &ranges, &valid, &elem_dtype)?;
+
+        let direct =
+            PrimitiveArray::from_option_iter([Some(4i64), Some(0i64), Some(0i64), Some(9i64)]);
+        assert_arrays_eq!(&actual, &direct.into_array());
+        assert_arrays_eq!(&actual, &expected);
+        Ok(())
+    }
+
+    #[test]
+    fn listview_overflow_group_is_null() -> VortexResult<()> {
+        let elements =
+            PrimitiveArray::new(buffer![i64::MAX, 1, 2, 3], Validity::NonNullable).into_array();
+        let elem_dtype = DType::Primitive(PType::I64, NonNullable);
+        let ranges = [(0, 2), (2, 2)];
+        let valid = [true, true];
+
+        let groups = listview(elements.clone(), &ranges, &valid)?;
+        let actual = grouped_sum_actual(&groups, &elem_dtype)?;
+        let expected = grouped_sum_reference(&elements, &ranges, &valid, &elem_dtype)?;
+
+        // First group overflows -> null sum; second group sums normally.
+        let direct = PrimitiveArray::from_option_iter([None, Some(5i64)]);
+        assert_arrays_eq!(&actual, &direct.into_array());
+        assert_arrays_eq!(&actual, &expected);
+        Ok(())
+    }
+
+    #[test]
+    fn listview_float_nan_and_inf() -> VortexResult<()> {
+        let elements = PrimitiveArray::new(
+            buffer![1.0f64, f64::NAN, 2.0, f64::INFINITY, f64::NEG_INFINITY, 4.0],
+            Validity::NonNullable,
+        )
+        .into_array();
+        let elem_dtype = DType::Primitive(PType::F64, NonNullable);
+        let ranges = [(0, 3), (3, 3)];
+        let valid = [true, true];
+
+        let groups = listview(elements.clone(), &ranges, &valid)?;
+        let actual = grouped_sum_actual(&groups, &elem_dtype)?;
+
+        // Group 0: NaN skipped -> 3.0. Group 1: INF + -INF = NaN. (Avoid array equality here since
+        // NaN != NaN; compare element scalars against the reference path instead.)
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let expected = grouped_sum_reference(&elements, &ranges, &valid, &elem_dtype)?;
+        let g0 = actual.execute_scalar(0, &mut ctx)?;
+        assert_eq!(g0.as_primitive().typed_value::<f64>(), Some(3.0));
+        assert_eq!(
+            g0.as_primitive().typed_value::<f64>(),
+            expected
+                .execute_scalar(0, &mut ctx)?
+                .as_primitive()
+                .typed_value::<f64>()
+        );
+        let g1 = actual.execute_scalar(1, &mut ctx)?;
+        assert!(g1.as_primitive().typed_value::<f64>().unwrap().is_nan());
+        assert!(
+            expected
+                .execute_scalar(1, &mut ctx)?
+                .as_primitive()
+                .typed_value::<f64>()
+                .unwrap()
+                .is_nan()
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn fixed_size_overflow_and_nan() -> VortexResult<()> {
+        // FixedSize path: first group overflows -> null sum, second sums normally.
+        let elements =
+            PrimitiveArray::new(buffer![i64::MAX, 1, 2, 3], Validity::NonNullable).into_array();
+        let elem_dtype = DType::Primitive(PType::I64, NonNullable);
+        let groups = FixedSizeListArray::try_new(elements.clone(), 2, Validity::NonNullable, 2)?
+            .into_array();
+
+        let actual = grouped_sum_actual(&groups, &elem_dtype)?;
+        let expected =
+            grouped_sum_reference(&elements, &[(0, 2), (2, 2)], &[true, true], &elem_dtype)?;
+        let direct = PrimitiveArray::from_option_iter([None, Some(5i64)]);
+        assert_arrays_eq!(&actual, &direct.into_array());
+        assert_arrays_eq!(&actual, &expected);
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/aggregate_fn/fns/sum/mod.rs b/vortex-array/src/aggregate_fn/fns/sum/mod.rs
index fb5f671e65d..9d525bec742 100644
--- a/vortex-array/src/aggregate_fn/fns/sum/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/sum/mod.rs
@@ -4,8 +4,9 @@
 mod bool;
 mod constant;
 mod decimal;
+mod grouped;
 mod primitive;
-
+pub(crate) use grouped::PrimitiveGroupedSumEncodingKernel;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
@@ -347,6 +348,7 @@ mod tests {
     use crate::arrays::ConstantArray;
     use crate::arrays::DecimalArray;
     use crate::arrays::FixedSizeListArray;
+    use crate::arrays::ListViewArray;
     use crate::arrays::PrimitiveArray;
     use crate::assert_arrays_eq;
     use crate::dtype::DType;
@@ -616,6 +618,25 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn grouped_sum_listview_out_of_order_offsets_with_null_group() -> VortexResult<()> {
+        let elements =
+            PrimitiveArray::new(buffer![100i32, 200, 300], Validity::NonNullable).into_array();
+        let offsets = PrimitiveArray::new(buffer![2i32, 0, 1], Validity::NonNullable).into_array();
+        let sizes = PrimitiveArray::new(buffer![1i32, 1, 1], Validity::NonNullable).into_array();
+        let validity = Validity::from_iter([true, false, true]);
+        let groups = ListViewArray::try_new(elements, offsets, sizes, validity)?.into_array();
+
+        let elem_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+        let result = run_grouped_sum(&groups, &elem_dtype)?;
+
+        // group 0 -> elements[2..3] = 300; group 1 -> null; group 2 -> elements[1..2] = 200.
+        let expected =
+            PrimitiveArray::from_option_iter([Some(300i64), None, Some(200i64)]).into_array();
+        assert_arrays_eq!(&result, &expected);
+        Ok(())
+    }
+
     // Chunked array tests
 
     #[test]
diff --git a/vortex-array/src/aggregate_fn/fns/sum/primitive.rs b/vortex-array/src/aggregate_fn/fns/sum/primitive.rs
index 44418fb5628..df7d929d896 100644
--- a/vortex-array/src/aggregate_fn/fns/sum/primitive.rs
+++ b/vortex-array/src/aggregate_fn/fns/sum/primitive.rs
@@ -50,11 +50,7 @@ fn accumulate_primitive_all(inner: &mut SumState, p: &PrimitiveArray) -> VortexR
             unsigned: |_T| { vortex_panic!("float sum state with unsigned input") },
             signed: |_T| { vortex_panic!("float sum state with signed input") },
             floating: |T| {
-                for &v in p.as_slice::<T>() {
-                    if !v.is_nan() {
-                        *acc += ToPrimitive::to_f64(&v).vortex_expect("float to f64");
-                    }
-                }
+                sum_float_all(acc, p.as_slice::<T>());
                 Ok(false)
             }
         ),
@@ -62,11 +58,21 @@ fn accumulate_primitive_all(inner: &mut SumState, p: &PrimitiveArray) -> VortexR
     }
 }
 
+/// Sum the non-NaN values of a float slice into an `f64` accumulator. NaNs are skipped to match the
+/// scalar `sum` semantics. Floats cannot overflow the accumulator, so this never reports saturation.
+pub(super) fn sum_float_all<T: NativePType>(acc: &mut f64, slice: &[T]) {
+    for &v in slice {
+        if !v.is_nan() {
+            *acc += ToPrimitive::to_f64(&v).vortex_expect("float to f64");
+        }
+    }
+}
+
 /// Sum all values into a `u64` accumulator. For types narrower than 64 bits, values are summed in
 /// chunks of [`SUM_CHUNK`] with a single checked add per chunk, which lets the inner loop vectorize
 /// to packed widening adds. `u64` input keeps a per-element checked add since a chunk of `u64`s
 /// could itself overflow. Returns `true` on overflow.
-fn sum_unsigned_all<T>(acc: &mut u64, slice: &[T]) -> bool
+pub(super) fn sum_unsigned_all<T>(acc: &mut u64, slice: &[T]) -> bool
 where
     T: NativePType + AsPrimitive<u64>,
 {
@@ -88,7 +94,7 @@ where
 }
 
 /// Signed counterpart of [`sum_unsigned_all`].
-fn sum_signed_all<T>(acc: &mut i64, slice: &[T]) -> bool
+pub(super) fn sum_signed_all<T>(acc: &mut i64, slice: &[T]) -> bool
 where
     T: NativePType + AsPrimitive<i64>,
 {
@@ -150,11 +156,7 @@ fn accumulate_primitive_valid(
             floating: |T| {
                 let values = p.as_slice::<T>();
                 for &(start, end) in slices {
-                    for &v in &values[start..end] {
-                        if !v.is_nan() {
-                            *acc += ToPrimitive::to_f64(&v).vortex_expect("float to f64");
-                        }
-                    }
+                    sum_float_all(acc, &values[start..end]);
                 }
                 Ok(false)
             }
diff --git a/vortex-array/src/aggregate_fn/fns/uncompressed_size_in_bytes/list_view.rs b/vortex-array/src/aggregate_fn/fns/uncompressed_size_in_bytes/list_view.rs
index 919430195d9..f75fcb92025 100644
--- a/vortex-array/src/aggregate_fn/fns/uncompressed_size_in_bytes/list_view.rs
+++ b/vortex-array/src/aggregate_fn/fns/uncompressed_size_in_bytes/list_view.rs
@@ -18,7 +18,7 @@ pub(super) fn list_view_uncompressed_size_in_bytes(
     let mut size = if array.is_empty() {
         0
     } else {
-        let rebuilt = array.rebuild(ListViewRebuildMode::MakeExact)?;
+        let rebuilt = array.rebuild(ListViewRebuildMode::MakeExact, ctx)?;
         uncompressed_size_in_bytes_u64(rebuilt.elements(), ctx)?
     };
 
diff --git a/vortex-array/src/aggregate_fn/kernels.rs b/vortex-array/src/aggregate_fn/kernels.rs
index d806b18d84d..c5af0902cbb 100644
--- a/vortex-array/src/aggregate_fn/kernels.rs
+++ b/vortex-array/src/aggregate_fn/kernels.rs
@@ -11,8 +11,7 @@ use vortex_error::VortexResult;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::aggregate_fn::AggregateFnRef;
-use crate::arrays::FixedSizeListArray;
-use crate::arrays::ListViewArray;
+use crate::aggregate_fn::GroupedArray;
 use crate::scalar::Scalar;
 
 /// A pluggable kernel for an aggregate function.
@@ -30,34 +29,24 @@ pub trait DynAggregateKernel: 'static + Send + Sync + Debug {
 
 /// A pluggable kernel for batch aggregation of many groups.
 ///
-/// The kernel is matched on the encoding of the _elements_ array, which is the inner array of the
-/// provided `ListViewArray`. This is more pragmatic than having every kernel match on the outer
-/// list encoding and having to deal with the possibility of multiple list encodings.
+/// A kernel can be registered either for an aggregate function regardless of the element encoding,
+/// or for a specific aggregate function and element encoding. Element-encoding kernels are matched
+/// on the inner array of the provided grouped array, not on the outer list encoding. This is more
+/// pragmatic than having every kernel match on the outer list encoding and having to deal with the
+/// possibility of multiple list encodings.
 ///
-/// Each element of the list array represents a group and the result of the grouped aggregate
+/// Each value in the grouped array represents a group and the result of the grouped aggregate
 /// should be an array of the same length, where each element is the aggregate state of the
 /// corresponding group.
 ///
 /// Return `Ok(None)` if the kernel cannot be applied to the given aggregate function.
 pub trait DynGroupedAggregateKernel: 'static + Send + Sync + Debug {
-    /// Aggregate each group in the provided `ListViewArray` and return an array of the
-    /// aggregate states.
+    /// Aggregate each group in the provided grouped array and return an array of the aggregate
+    /// states.
     fn grouped_aggregate(
         &self,
         aggregate_fn: &AggregateFnRef,
-        groups: &ListViewArray,
+        groups: &GroupedArray,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<Option<ArrayRef>>;
-
-    /// Aggregate each group in the provided `FixedSizeListArray` and return an array of the
-    /// aggregate states.
-    fn grouped_aggregate_fixed_size(
-        &self,
-        aggregate_fn: &AggregateFnRef,
-        groups: &FixedSizeListArray,
-    ) -> VortexResult<Option<ArrayRef>> {
-        // TODO(ngates): we could automatically delegate to `grouped_aggregate` if SequenceArray
-        //  was in the vortex-array crate
-        let _ = (aggregate_fn, groups);
-        Ok(None)
-    }
 }
diff --git a/vortex-array/src/aggregate_fn/proto.rs b/vortex-array/src/aggregate_fn/proto.rs
index 9bcfab5818c..bff198b3955 100644
--- a/vortex-array/src/aggregate_fn/proto.rs
+++ b/vortex-array/src/aggregate_fn/proto.rs
@@ -36,7 +36,7 @@ impl AggregateFnRef {
     /// Note: the serialization format is not stable and may change between versions.
     pub fn from_proto(proto: &pb::AggregateFn, session: &VortexSession) -> VortexResult<Self> {
         let agg_fn_id: AggregateFnId = AggregateFnId::new(proto.id.as_str());
-        let agg_fn = if let Some(plugin) = session.aggregate_fns().registry().find(&agg_fn_id) {
+        let agg_fn = if let Some(plugin) = session.aggregate_fns().find_plugin(&agg_fn_id) {
             plugin.deserialize(proto.metadata(), session)?
         } else if session.allows_unknown() {
             new_foreign_aggregate_fn(agg_fn_id, proto.metadata().to_vec())
diff --git a/vortex-array/src/aggregate_fn/session.rs b/vortex-array/src/aggregate_fn/session.rs
index d89f9da069d..c6d7542a687 100644
--- a/vortex-array/src/aggregate_fn/session.rs
+++ b/vortex-array/src/aggregate_fn/session.rs
@@ -4,12 +4,9 @@
 use std::any::Any;
 use std::sync::Arc;
 
-use parking_lot::RwLock;
 use vortex_session::Ref;
 use vortex_session::SessionExt;
 use vortex_session::SessionVar;
-use vortex_session::registry::Registry;
-use vortex_utils::aliases::hash_map::HashMap;
 
 use crate::aggregate_fn::AggregateFnId;
 use crate::aggregate_fn::AggregateFnPluginRef;
@@ -21,6 +18,8 @@ use crate::aggregate_fn::fns::all_non_null::AllNonNull;
 use crate::aggregate_fn::fns::all_null::AllNull;
 use crate::aggregate_fn::fns::bounded_max::BoundedMax;
 use crate::aggregate_fn::fns::bounded_min::BoundedMin;
+use crate::aggregate_fn::fns::count::Count;
+use crate::aggregate_fn::fns::count::CountGroupedKernel;
 use crate::aggregate_fn::fns::first::First;
 use crate::aggregate_fn::fns::is_constant::IsConstant;
 use crate::aggregate_fn::fns::is_sorted::IsSorted;
@@ -30,29 +29,35 @@ use crate::aggregate_fn::fns::min::Min;
 use crate::aggregate_fn::fns::min_max::MinMax;
 use crate::aggregate_fn::fns::nan_count::NanCount;
 use crate::aggregate_fn::fns::null_count::NullCount;
+use crate::aggregate_fn::fns::sum::PrimitiveGroupedSumEncodingKernel;
 use crate::aggregate_fn::fns::sum::Sum;
 use crate::aggregate_fn::fns::uncompressed_size_in_bytes::UncompressedSizeInBytes;
 use crate::aggregate_fn::kernels::DynAggregateKernel;
 use crate::aggregate_fn::kernels::DynGroupedAggregateKernel;
+use crate::arc_swap_map::ArcSwapMap;
 use crate::array::ArrayId;
 use crate::array::VTable;
 use crate::arrays::Chunked;
 use crate::arrays::Dict;
+use crate::arrays::Primitive;
 use crate::arrays::chunked::compute::aggregate::ChunkedArrayAggregate;
 use crate::arrays::dict::compute::is_constant::DictIsConstantKernel;
 use crate::arrays::dict::compute::is_sorted::DictIsSortedKernel;
 use crate::arrays::dict::compute::min_max::DictMinMaxKernel;
 
-/// Registry of aggregate function vtables.
-pub type AggregateFnRegistry = Registry<AggregateFnPluginRef>;
-
-/// Session state for aggregate function vtables.
+/// Session state for aggregate functions and encoding-specific aggregate kernels.
+///
+/// The default session registers the built-in aggregate functions and kernels. Additional
+/// aggregate functions and kernels may be registered by extensions when they are added to a
+/// [`VortexSession`](vortex_session::VortexSession).
 #[derive(Debug)]
 pub struct AggregateFnSession {
-    registry: AggregateFnRegistry,
+    registry: ArcSwapMap<AggregateFnId, AggregateFnPluginRef>,
 
-    pub(super) kernels: RwLock<HashMap<KernelKey, &'static dyn DynAggregateKernel>>,
-    pub(super) grouped_kernels: RwLock<HashMap<KernelKey, &'static dyn DynGroupedAggregateKernel>>,
+    kernels: ArcSwapMap<AggregateKernelKey, &'static dyn DynAggregateKernel>,
+    grouped_kernels: ArcSwapMap<AggregateFnId, &'static dyn DynGroupedAggregateKernel>,
+    grouped_encoding_kernels:
+        ArcSwapMap<GroupedEncodingKernelKey, &'static dyn DynGroupedAggregateKernel>,
 }
 
 impl SessionVar for AggregateFnSession {
@@ -65,14 +70,16 @@ impl SessionVar for AggregateFnSession {
     }
 }
 
-type KernelKey = (ArrayId, Option<AggregateFnId>);
+type AggregateKernelKey = (ArrayId, Option<AggregateFnId>);
+type GroupedEncodingKernelKey = (ArrayId, AggregateFnId);
 
 impl Default for AggregateFnSession {
     fn default() -> Self {
         let this = Self {
-            registry: AggregateFnRegistry::default(),
-            kernels: RwLock::new(HashMap::default()),
-            grouped_kernels: RwLock::new(HashMap::default()),
+            registry: ArcSwapMap::default(),
+            kernels: ArcSwapMap::default(),
+            grouped_kernels: ArcSwapMap::default(),
+            grouped_encoding_kernels: ArcSwapMap::default(),
         };
 
         // Register the built-in aggregate functions
@@ -101,39 +108,120 @@ impl Default for AggregateFnSession {
         this.register_aggregate_kernel(Dict.id(), Some(IsConstant.id()), &DictIsConstantKernel);
         this.register_aggregate_kernel(Dict.id(), Some(IsSorted.id()), &DictIsSortedKernel);
 
+        // Register the built-in grouped aggregate kernels.
+        this.register_grouped_kernel(Count.id(), &CountGroupedKernel);
+        this.register_grouped_encoding_kernel(
+            Primitive.id(),
+            Sum.id(),
+            &PrimitiveGroupedSumEncodingKernel,
+        );
+
         this
     }
 }
 
 impl AggregateFnSession {
-    /// Returns the aggregate function registry.
-    pub fn registry(&self) -> &AggregateFnRegistry {
-        &self.registry
+    /// Returns the aggregate function plugin registered for `id`, if any.
+    pub fn find_plugin(&self, id: &AggregateFnId) -> Option<AggregateFnPluginRef> {
+        self.registry.get(id)
     }
 
     /// Register an aggregate function vtable in the session, replacing any existing vtable with
     /// the same ID.
     pub fn register<V: AggregateFnVTable>(&self, vtable: V) {
-        self.registry
-            .register(vtable.id(), Arc::new(vtable) as AggregateFnPluginRef);
+        let id = vtable.id();
+        let pluginref = Arc::new(vtable) as AggregateFnPluginRef;
+        self.registry.insert(id, pluginref);
+    }
+
+    /// Returns the aggregate kernel registered for `array_id` and `agg_fn_id`, if any.
+    ///
+    /// Lookup first checks for a kernel registered for the exact aggregate function, then falls
+    /// back to a kernel registered for all aggregate functions on the same array encoding.
+    pub fn find_aggregate_kernel(
+        &self,
+        array_id: impl Into<ArrayId>,
+        agg_fn_id: impl Into<AggregateFnId>,
+    ) -> Option<&'static dyn DynAggregateKernel> {
+        let id = array_id.into();
+        let fn_id = agg_fn_id.into();
+        self.kernels.read(|kernels| {
+            kernels
+                .get(&(id, Some(fn_id)))
+                .or_else(|| kernels.get(&(id, None)))
+                .copied()
+        })
     }
 
-    /// Register an aggregate function kernel for a specific aggregate function and array type.
+    /// Registers an aggregate kernel for an array encoding.
+    ///
+    /// When `agg_fn_id` is `Some`, the kernel is used only for that aggregate function. When
+    /// `agg_fn_id` is `None`, the kernel is used as the fallback for aggregate functions on the
+    /// array encoding that do not have a more specific kernel.
     pub fn register_aggregate_kernel(
         &self,
         array_id: impl Into<ArrayId>,
         agg_fn_id: Option<impl Into<AggregateFnId>>,
         kernel: &'static dyn DynAggregateKernel,
     ) {
-        self.kernels
-            .write()
-            .insert((array_id.into(), agg_fn_id.map(|id| id.into())), kernel);
+        let id = (array_id.into(), agg_fn_id.map(|id| id.into()));
+        self.kernels.insert(id, kernel);
+    }
+
+    /// Returns the grouped aggregate kernel registered for `agg_fn_id`, if any.
+    ///
+    /// These kernels are independent of the element encoding and are checked for each element
+    /// representation, after any kernel registered for the current element encoding.
+    pub fn find_grouped_kernel(
+        &self,
+        agg_fn_id: impl Into<AggregateFnId>,
+    ) -> Option<&'static dyn DynGroupedAggregateKernel> {
+        let fn_id = agg_fn_id.into();
+        self.grouped_kernels
+            .read(|kernels| kernels.get(&fn_id).copied())
+    }
+
+    /// Registers a grouped aggregate kernel for an aggregate function.
+    pub fn register_grouped_kernel(
+        &self,
+        agg_fn_id: impl Into<AggregateFnId>,
+        kernel: &'static dyn DynGroupedAggregateKernel,
+    ) {
+        let fn_id = agg_fn_id.into();
+        self.grouped_kernels.insert(fn_id, kernel)
+    }
+
+    /// Returns the grouped aggregate kernel registered for `array_id` and `agg_fn_id`, if any.
+    ///
+    /// These kernels are matched against each intermediate element encoding while the grouped
+    /// accumulator executes the element array.
+    pub fn find_grouped_encoding_kernel(
+        &self,
+        array_id: impl Into<ArrayId>,
+        agg_fn_id: impl Into<AggregateFnId>,
+    ) -> Option<&'static dyn DynGroupedAggregateKernel> {
+        let id = array_id.into();
+        let fn_id = agg_fn_id.into();
+        self.grouped_encoding_kernels
+            .read(|kernels| kernels.get(&(id, fn_id)).copied())
+    }
+
+    /// Registers a grouped aggregate kernel for a specific aggregate function and array encoding.
+    pub fn register_grouped_encoding_kernel(
+        &self,
+        array_id: impl Into<ArrayId>,
+        agg_fn_id: impl Into<AggregateFnId>,
+        kernel: &'static dyn DynGroupedAggregateKernel,
+    ) {
+        let id = array_id.into();
+        let fn_id = agg_fn_id.into();
+        self.grouped_encoding_kernels.insert((id, fn_id), kernel)
     }
 }
 
 /// Extension trait for accessing aggregate function session data.
 pub trait AggregateFnSessionExt: SessionExt {
-    /// Returns the aggregate function vtable registry.
+    /// Returns the aggregate function session data.
     fn aggregate_fns(&self) -> Ref<'_, AggregateFnSession> {
         self.get::<AggregateFnSession>()
     }
diff --git a/vortex-array/src/arc_swap_map.rs b/vortex-array/src/arc_swap_map.rs
new file mode 100644
index 00000000000..aff46c22d73
--- /dev/null
+++ b/vortex-array/src/arc_swap_map.rs
@@ -0,0 +1,151 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! A concurrent, copy-on-write map backed by an [`ArcSwap`].
+
+use std::borrow::Borrow;
+use std::fmt::Debug;
+use std::fmt::Formatter;
+use std::hash::Hash;
+use std::sync::Arc;
+
+use arc_swap::ArcSwap;
+use vortex_utils::aliases::hash_map::HashMap;
+
+/// A concurrent [`HashMap`] backed by an [`ArcSwap`], offering lock-free reads
+/// and copy-on-write writes.
+///
+/// Reads load the current snapshot without blocking writers. Writes clone the
+/// whole map, apply their change, and atomically publish the new version, so a
+/// reader always observes a consistent snapshot and writers never block readers.
+///
+/// This is the shared building block behind the session-scoped registries (the
+/// optimizer-kernel and aggregate-function registries). Because every write
+/// clones the entire map, it is intended for maps that are written rarely
+/// (typically only while a session is being configured) and read often.
+pub(crate) struct ArcSwapMap<K, V> {
+    inner: ArcSwap<HashMap<K, V>>,
+}
+
+impl<K, V> Default for ArcSwapMap<K, V> {
+    fn default() -> Self {
+        Self {
+            inner: ArcSwap::from_pointee(HashMap::default()),
+        }
+    }
+}
+
+impl<K: Debug, V: Debug> Debug for ArcSwapMap<K, V> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        self.read(|map| f.debug_tuple("ArcSwapMap").field(map).finish())
+    }
+}
+
+impl<K, V> ArcSwapMap<K, V> {
+    /// Read the current snapshot, passing it to `f`.
+    ///
+    /// Every lookup inside `f` observes the same snapshot, which matters when a
+    /// single logical read consults more than one key.
+    pub(crate) fn read<R>(&self, f: impl FnOnce(&HashMap<K, V>) -> R) -> R {
+        f(&self.inner.load())
+    }
+
+    /// Replace the map with the result of applying `f` to a private copy.
+    ///
+    /// Writes are copy-on-write via [`ArcSwap::rcu`], so `f` may run more than
+    /// once under contention and must not move out of its captures.
+    fn modify(&self, f: impl Fn(&mut HashMap<K, V>))
+    where
+        K: Clone,
+        V: Clone,
+    {
+        self.inner.rcu(|existing| {
+            let mut map = existing.as_ref().clone();
+            f(&mut map);
+            map
+        });
+    }
+}
+
+impl<K: Eq + Hash, V: Clone> ArcSwapMap<K, V> {
+    /// Return a clone of the value stored under `key`, if present.
+    pub(crate) fn get<Q>(&self, key: &Q) -> Option<V>
+    where
+        K: Borrow<Q>,
+        Q: Eq + Hash + ?Sized,
+    {
+        self.inner.load().get(key).cloned()
+    }
+
+    /// Insert `value` under `key`, replacing any existing value.
+    pub(crate) fn insert(&self, key: K, value: V)
+    where
+        K: Clone,
+    {
+        self.modify(|map| {
+            map.insert(key.clone(), value.clone());
+        });
+    }
+}
+
+impl<K: Eq + Hash + Clone, T: Clone> ArcSwapMap<K, Arc<[T]>> {
+    /// Append `values` to the list stored under `key`, creating it if absent.
+    ///
+    /// Each key maps to an immutable `Arc<[T]>`; appending rebuilds that slice
+    /// copy-on-write so existing readers keep their previous snapshot.
+    pub(crate) fn extend(&self, key: K, values: &[T]) {
+        self.modify(|map| {
+            let merged: Arc<[T]> = match map.get(&key) {
+                Some(existing) => existing.iter().chain(values).cloned().collect(),
+                None => values.into(),
+            };
+            map.insert(key.clone(), merged);
+        });
+    }
+
+    /// Append a single `value` to the list stored under `key`, creating it if
+    /// absent.
+    pub(crate) fn push(&self, key: K, value: T) {
+        self.extend(key, &[value]);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn get_and_insert() {
+        let map = ArcSwapMap::<u32, i32>::default();
+        assert_eq!(map.get(&1), None);
+        map.insert(1, 10);
+        map.insert(1, 20);
+        assert_eq!(map.get(&1), Some(20));
+    }
+
+    #[test]
+    fn extend_appends_per_key() {
+        let map = ArcSwapMap::<u32, Arc<[i32]>>::default();
+        map.extend(1, &[1, 2]);
+        map.extend(1, &[3]);
+        map.extend(2, &[4]);
+        assert_eq!(map.get(&1).as_deref(), Some([1, 2, 3].as_slice()));
+        assert_eq!(map.get(&2).as_deref(), Some([4].as_slice()));
+    }
+
+    #[test]
+    fn push_appends_single_values() {
+        let map = ArcSwapMap::<u32, Arc<[i32]>>::default();
+        map.push(1, 1);
+        map.push(1, 2);
+        assert_eq!(map.get(&1).as_deref(), Some([1, 2].as_slice()));
+    }
+
+    #[test]
+    fn read_observes_a_single_snapshot() {
+        let map = ArcSwapMap::<u32, i32>::default();
+        map.insert(1, 1);
+        map.insert(2, 2);
+        assert_eq!(map.read(|m| m.values().sum::<i32>()), 3);
+    }
+}
diff --git a/vortex-array/src/array/erased.rs b/vortex-array/src/array/erased.rs
index 77800377f1c..bacda957660 100644
--- a/vortex-array/src/array/erased.rs
+++ b/vortex-array/src/array/erased.rs
@@ -47,13 +47,13 @@ use crate::arrays::VarBinView;
 use crate::buffer::BufferHandle;
 use crate::builders::ArrayBuilder;
 use crate::dtype::DType;
-use crate::dtype::Nullability;
 use crate::expr::stats::Precision;
 use crate::expr::stats::Stat;
 use crate::expr::stats::StatsProviderExt;
 use crate::matcher::Matcher;
 use crate::optimizer::ArrayOptimizer;
 use crate::scalar::Scalar;
+use crate::scalar::ScalarValue;
 use crate::stats::StatsSetRef;
 use crate::validity::Validity;
 
@@ -155,22 +155,22 @@ impl Debug for ArrayRef {
 }
 
 impl ArrayHash for ArrayRef {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: crate::Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, accuracy: crate::EqMode) {
         self.0.len.hash(state);
         self.0.dtype.hash(state);
         self.0.encoding_id.hash(state);
         self.0.slots.len().hash(state);
         for slot in &self.0.slots {
-            slot.array_hash(state, precision);
+            slot.array_hash(state, accuracy);
         }
         self.0
             .data
-            .dyn_array_hash(state as &mut dyn Hasher, precision);
+            .dyn_array_hash(state as &mut dyn Hasher, accuracy);
     }
 }
 
 impl ArrayEq for ArrayRef {
-    fn array_eq(&self, other: &Self, precision: crate::Precision) -> bool {
+    fn array_eq(&self, other: &Self, accuracy: crate::EqMode) -> bool {
         self.0.len == other.0.len
             && self.0.dtype == other.0.dtype
             && self.0.encoding_id == other.0.encoding_id
@@ -180,8 +180,8 @@ impl ArrayEq for ArrayRef {
                 .slots
                 .iter()
                 .zip(other.0.slots.iter())
-                .all(|(slot, other_slot)| slot.array_eq(other_slot, precision))
-            && self.0.data.dyn_array_eq(other, precision)
+                .all(|(slot, other_slot)| slot.array_eq(other_slot, accuracy))
+            && self.0.data.dyn_array_eq(other, accuracy)
     }
 }
 impl ArrayRef {
@@ -239,13 +239,10 @@ impl ArrayRef {
                     matches!(
                         stat,
                         Stat::IsConstant | Stat::IsSorted | Stat::IsStrictSorted
-                    ) && value.as_ref().as_exact().is_some_and(|v| {
-                        Scalar::try_new(DType::Bool(Nullability::NonNullable), Some(v.clone()))
-                            .vortex_expect("A stat that was expected to be a boolean stat was not")
-                            .as_bool()
-                            .value()
-                            .unwrap_or_default()
-                    })
+                    ) && value
+                        .as_ref()
+                        .as_exact()
+                        .is_some_and(|v| matches!(v, ScalarValue::Bool(true)))
                 }));
             });
         }
@@ -390,16 +387,19 @@ impl ArrayRef {
     }
 
     /// Does the array match the given matcher.
+    #[inline]
     pub fn is<M: Matcher>(&self) -> bool {
         M::matches(self)
     }
 
     /// Returns the array downcast by the given matcher.
+    #[inline]
     pub fn as_<M: Matcher>(&self) -> M::Match<'_> {
         self.as_opt::<M>().vortex_expect("Failed to downcast")
     }
 
     /// Returns the array downcast by the given matcher.
+    #[inline]
     pub fn as_opt<M: Matcher>(&self) -> Option<M::Match<'_>> {
         M::try_match(self)
     }
@@ -494,7 +494,7 @@ impl ArrayRef {
     /// Take a slot for executor-owned physical rewrites.
     ///
     /// On return the produced parent has the taken slot set to `None`
-    /// callers must put the slot back (typically via [`put_slot_unchecked`]) before the parent is
+    /// callers must put the slot back (typically via [`Self::put_slot_unchecked`]) before the parent is
     /// returned from the execution loop.
     ///
     /// When the `Arc` was shared this allocates a fresh parent.
@@ -531,7 +531,7 @@ impl ArrayRef {
 
     /// Puts an array into `slot_idx` by either, cloning the inner array if the Arc is not exclusive
     /// or replacing the slot in this `ArrayRef`.
-    /// This is the mirror of [`take_slot_unchecked`].
+    /// This is the mirror of [`Self::take_slot_unchecked`].
     ///
     /// # Safety
     /// The replacement must have the same logical dtype and length as the taken slot, and this
@@ -738,10 +738,12 @@ impl IntoArray for ArrayRef {
 impl<V: VTable> Matcher for V {
     type Match<'a> = ArrayView<'a, V>;
 
+    #[inline]
     fn matches(array: &ArrayRef) -> bool {
         array.0.data.as_any().is::<ArrayData<V>>()
     }
 
+    #[inline]
     fn try_match(array: &'_ ArrayRef) -> Option<ArrayView<'_, V>> {
         let inner = array.0.data.as_any().downcast_ref::<ArrayData<V>>()?;
         // # Safety checked by `downcast_ref`.
diff --git a/vortex-array/src/array/foreign.rs b/vortex-array/src/array/foreign.rs
index a7ee238d1f1..e7ea7238346 100644
--- a/vortex-array/src/array/foreign.rs
+++ b/vortex-array/src/array/foreign.rs
@@ -49,24 +49,24 @@ impl Display for ForeignArrayData {
 }
 
 impl ArrayHash for ForeignArrayData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: crate::Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, accuracy: crate::EqMode) {
         self.metadata.hash(state);
         self.buffers.len().hash(state);
         for buffer in &self.buffers {
-            buffer.array_hash(state, precision);
+            buffer.array_hash(state, accuracy);
         }
     }
 }
 
 impl ArrayEq for ForeignArrayData {
-    fn array_eq(&self, other: &Self, precision: crate::Precision) -> bool {
+    fn array_eq(&self, other: &Self, accuracy: crate::EqMode) -> bool {
         self.metadata == other.metadata
             && self.buffers.len() == other.buffers.len()
             && self
                 .buffers
                 .iter()
                 .zip(other.buffers.iter())
-                .all(|(lhs, rhs)| lhs.array_eq(rhs, precision))
+                .all(|(lhs, rhs)| lhs.array_eq(rhs, accuracy))
     }
 }
 
diff --git a/vortex-array/src/array/mod.rs b/vortex-array/src/array/mod.rs
index 23ad9499766..b1b22c4c529 100644
--- a/vortex-array/src/array/mod.rs
+++ b/vortex-array/src/array/mod.rs
@@ -119,10 +119,10 @@ pub(crate) trait DynArrayData: 'static + private::Sealed + Send + Sync + Debug {
     fn metadata_fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result;
 
     /// Hashes the array contents including len, dtype, and encoding id.
-    fn dyn_array_hash(&self, state: &mut dyn Hasher, precision: crate::Precision);
+    fn dyn_array_hash(&self, state: &mut dyn Hasher, accuracy: crate::EqMode);
 
     /// Compares two arrays of the same concrete type for equality.
-    fn dyn_array_eq(&self, other: &ArrayRef, precision: crate::Precision) -> bool;
+    fn dyn_array_eq(&self, other: &ArrayRef, accuracy: crate::EqMode) -> bool;
 
     /// Returns a new array with the given slots.
     fn with_slots(&self, this: &ArrayRef, slots: ArraySlots) -> VortexResult<ArrayRef>;
@@ -341,19 +341,19 @@ impl<V: VTable> DynArrayData for ArrayData<V> {
         std::fmt::Display::fmt(&self.data, f)
     }
 
-    fn dyn_array_hash(&self, state: &mut dyn Hasher, precision: crate::Precision) {
+    fn dyn_array_hash(&self, state: &mut dyn Hasher, accuracy: crate::EqMode) {
         let mut wrapper = HasherWrapper(state);
         // Note: metadata (len, dtype, encoding_id) and slots are hashed by ArrayRef.
-        self.data.array_hash(&mut wrapper, precision);
+        self.data.array_hash(&mut wrapper, accuracy);
     }
 
-    fn dyn_array_eq(&self, other: &ArrayRef, precision: crate::Precision) -> bool {
+    fn dyn_array_eq(&self, other: &ArrayRef, accuracy: crate::EqMode) -> bool {
         // Note: metadata (len, dtype, encoding_id) and slots are compared by ArrayRef.
         other
             .dyn_array()
             .as_any()
             .downcast_ref::<Self>()
-            .is_some_and(|other_inner| self.data.array_eq(&other_inner.data, precision))
+            .is_some_and(|other_inner| self.data.array_eq(&other_inner.data, accuracy))
     }
 
     fn with_slots(&self, this: &ArrayRef, slots: ArraySlots) -> VortexResult<ArrayRef> {
diff --git a/vortex-array/src/array/vtable/mod.rs b/vortex-array/src/array/vtable/mod.rs
index 6c85bb79d05..366eed77ad9 100644
--- a/vortex-array/src/array/vtable/mod.rs
+++ b/vortex-array/src/array/vtable/mod.rs
@@ -22,9 +22,9 @@ use crate::Array;
 use crate::ArrayRef;
 use crate::ArrayView;
 use crate::Canonical;
+use crate::EqMode;
 use crate::ExecutionResult;
 use crate::IntoArray;
-use crate::Precision;
 pub use crate::array::plugin::*;
 use crate::arrays::ConstantArray;
 use crate::arrays::constant::Constant;
@@ -223,12 +223,12 @@ use crate::array::ArrayId;
 pub struct EmptyArrayData;
 
 impl ArrayEq for EmptyArrayData {
-    fn array_eq(&self, _other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, _other: &Self, _accuracy: EqMode) -> bool {
         true
     }
 }
 impl ArrayHash for EmptyArrayData {
-    fn array_hash<H: Hasher>(&self, _state: &mut H, _precision: Precision) {}
+    fn array_hash<H: Hasher>(&self, _state: &mut H, _accuracy: EqMode) {}
 }
 
 impl Display for EmptyArrayData {
diff --git a/vortex-array/src/arrays/bool/array.rs b/vortex-array/src/arrays/bool/array.rs
index 6585e705899..82df2f9c167 100644
--- a/vortex-array/src/arrays/bool/array.rs
+++ b/vortex-array/src/arrays/bool/array.rs
@@ -7,7 +7,9 @@ use std::fmt::Formatter;
 use arrow_array::BooleanArray;
 use smallvec::smallvec;
 use vortex_buffer::BitBuffer;
+use vortex_buffer::BitBufferMeta;
 use vortex_buffer::BitBufferMut;
+use vortex_buffer::BitBufferView;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
@@ -69,19 +71,18 @@ pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["validity"];
 #[derive(Clone, Debug)]
 pub struct BoolData {
     pub(super) bits: BufferHandle,
-    pub(super) offset: usize,
+    pub(super) meta: BitBufferMeta,
 }
 
 impl Display for BoolData {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "offset: {}", self.offset)
+        write!(f, "offset: {}", self.meta.offset())
     }
 }
 
 pub struct BoolDataParts {
     pub bits: BufferHandle,
-    pub offset: usize,
-    pub len: usize,
+    pub meta: BitBufferMeta,
 }
 
 pub trait BoolArrayExt: TypedArrayRef<Bool> {
@@ -101,7 +102,12 @@ pub trait BoolArrayExt: TypedArrayRef<Bool> {
 
     fn to_bit_buffer(&self) -> BitBuffer {
         let buffer = self.bits.as_host().clone();
-        BitBuffer::new_with_offset(buffer, self.as_ref().len(), self.offset)
+        BitBuffer::new_with_offset(buffer, self.meta.len(), self.meta.offset())
+    }
+
+    /// Borrow the array's packed bits as a [`BitBufferView`] without cloning the backing buffer.
+    fn bit_buffer_view(&self) -> BitBufferView<'_> {
+        BitBufferView::from_meta(self.bits.as_host().as_slice(), self.meta)
     }
 
     fn maybe_execute_mask(&self, ctx: &mut ExecutionCtx) -> VortexResult<Option<Mask>> {
@@ -141,8 +147,7 @@ impl BoolData {
     pub fn into_parts(self, len: usize) -> BoolDataParts {
         BoolDataParts {
             bits: self.bits,
-            offset: self.offset,
-            len,
+            meta: BitBufferMeta::new(self.meta.offset(), len),
         }
     }
 
@@ -151,9 +156,9 @@ impl BoolData {
     }
 }
 
-/// Constructors and consuming methods for `BoolArray` (`Array<Bool>`).
+/// Constructors and consuming methods for [`BoolArray`].
 impl Array<Bool> {
-    /// Constructs a new `BoolArray`.
+    /// Constructs a new [`BoolArray`].
     ///
     /// # Panics
     ///
@@ -162,7 +167,7 @@ impl Array<Bool> {
         Self::try_new(bits, validity).vortex_expect("Failed to create BoolArray")
     }
 
-    /// Constructs a new `BoolArray` from a `BufferHandle`.
+    /// Constructs a new [`BoolArray`] from a [`BufferHandle`].
     ///
     /// # Panics
     ///
@@ -242,21 +247,21 @@ impl Array<Bool> {
         let len = self.len();
         let data = self.into_data();
         let buffer = data.bits.unwrap_host();
-        BitBuffer::new_with_offset(buffer, len, data.offset)
+        BitBuffer::new_with_offset(buffer, len, data.meta.offset())
     }
 }
 
-/// Internal constructors on BoolData (used by Array<Bool> constructors and VTable::build).
+// Internal constructors on BoolData (used by [`BoolArray`] constructors and [`VTable::build`]).
 impl BoolData {
     pub(super) fn try_new(bits: BitBuffer, validity: Validity) -> VortexResult<Self> {
         let bits = bits.shrink_offset();
         Self::validate(&bits, &validity)?;
 
-        let (offset, _len, buffer) = bits.into_inner();
+        let (offset, len, buffer) = bits.into_inner();
 
         Ok(Self {
             bits: BufferHandle::new_host(buffer),
-            offset,
+            meta: BitBufferMeta::new(offset, len),
         })
     }
 
@@ -281,18 +286,21 @@ impl BoolData {
             bits.len() * 8,
         );
 
-        Ok(Self { bits, offset })
+        Ok(Self {
+            bits,
+            meta: BitBufferMeta::new(offset, len),
+        })
     }
 
     pub(super) unsafe fn new_unchecked(bits: BitBuffer, validity: Validity) -> Self {
         if cfg!(debug_assertions) {
             Self::try_new(bits, validity).vortex_expect("Failed to create BoolData")
         } else {
-            let (offset, _len, buffer) = bits.into_inner();
+            let (offset, len, buffer) = bits.into_inner();
 
             Self {
                 bits: BufferHandle::new_host(buffer),
-                offset,
+                meta: BitBufferMeta::new(offset, len),
             }
         }
     }
diff --git a/vortex-array/src/arrays/bool/compute/mod.rs b/vortex-array/src/arrays/bool/compute/mod.rs
index 9649bd31d6c..9b71578cd84 100644
--- a/vortex-array/src/arrays/bool/compute/mod.rs
+++ b/vortex-array/src/arrays/bool/compute/mod.rs
@@ -8,6 +8,7 @@ mod mask;
 pub mod rules;
 mod slice;
 mod take;
+mod zip;
 
 #[cfg(test)]
 mod tests {
diff --git a/vortex-array/src/arrays/bool/compute/rules.rs b/vortex-array/src/arrays/bool/compute/rules.rs
index ed2e7a4dc28..43f811785ea 100644
--- a/vortex-array/src/arrays/bool/compute/rules.rs
+++ b/vortex-array/src/arrays/bool/compute/rules.rs
@@ -45,14 +45,15 @@ impl ArrayParentReduceRule<Bool> for BoolMaskedValidityRule {
             return Ok(None);
         }
 
+        let bit_buffer = array.to_bit_buffer();
         // Merge the parent's validity mask into the child's validity
         // TODO(joe): make this lazy
-        Ok(Some(
-            BoolArray::new(
-                array.to_bit_buffer(),
-                array.validity()?.and(parent.validity()?)?,
-            )
-            .into_array(),
-        ))
+        let validity = array.validity()?.and(parent.validity()?)?;
+
+        // Safety:
+        // we know all elements are valid, the AND operation will fail if mismatched.
+        let array = unsafe { BoolArray::new_unchecked(bit_buffer, validity).into_array() };
+
+        Ok(Some(array))
     }
 }
diff --git a/vortex-array/src/arrays/bool/compute/slice.rs b/vortex-array/src/arrays/bool/compute/slice.rs
index 0ef11bb3085..0b38d2a6117 100644
--- a/vortex-array/src/arrays/bool/compute/slice.rs
+++ b/vortex-array/src/arrays/bool/compute/slice.rs
@@ -15,12 +15,13 @@ use crate::arrays::slice::SliceReduce;
 
 impl SliceReduce for Bool {
     fn slice(array: ArrayView<'_, Bool>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
-        Ok(Some(
-            BoolArray::new(
-                array.to_bit_buffer().slice(range.clone()),
-                array.validity()?.slice(range)?,
-            )
-            .into_array(),
-        ))
+        let bit_buffer = array.to_bit_buffer().slice(range.clone());
+        let validity = array.validity()?.slice(range)?;
+
+        // Safety:
+        // range is verified in the callers and is the same for both bits and validity.
+        let array = unsafe { BoolArray::new_unchecked(bit_buffer, validity).into_array() };
+
+        Ok(Some(array))
     }
 }
diff --git a/vortex-array/src/arrays/bool/compute/take.rs b/vortex-array/src/arrays/bool/compute/take.rs
index 1f679445254..d70579136a4 100644
--- a/vortex-array/src/arrays/bool/compute/take.rs
+++ b/vortex-array/src/arrays/bool/compute/take.rs
@@ -4,6 +4,7 @@
 use itertools::Itertools as _;
 use num_traits::AsPrimitive;
 use vortex_buffer::BitBuffer;
+use vortex_buffer::BitBufferView;
 use vortex_buffer::get_bit;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
@@ -42,7 +43,10 @@ impl TakeExecute for Bool {
         };
         let indices_nulls_zeroed = indices_nulls_zeroed.execute::<PrimitiveArray>(ctx)?;
         let buffer = match_each_integer_ptype!(indices_nulls_zeroed.ptype(), |I| {
-            take_valid_indices(&array.to_bit_buffer(), indices_nulls_zeroed.as_slice::<I>())
+            take_valid_indices(
+                array.bit_buffer_view(),
+                indices_nulls_zeroed.as_slice::<I>(),
+            )
         });
 
         Ok(Some(
@@ -51,7 +55,7 @@ impl TakeExecute for Bool {
     }
 }
 
-fn take_valid_indices<I: AsPrimitive<usize>>(bools: &BitBuffer, indices: &[I]) -> BitBuffer {
+fn take_valid_indices<I: AsPrimitive<usize>>(bools: BitBufferView<'_>, indices: &[I]) -> BitBuffer {
     // For boolean arrays that roughly fit into a single page (at least, on Linux), it's worth
     // the overhead to convert to a Vec<bool>.
     if bools.len() <= 4096 {
@@ -68,9 +72,9 @@ fn take_byte_bool<I: AsPrimitive<usize>>(bools: Vec<bool>, indices: &[I]) -> Bit
     })
 }
 
-fn take_bool_impl<I: AsPrimitive<usize>>(bools: &BitBuffer, indices: &[I]) -> BitBuffer {
+fn take_bool_impl<I: AsPrimitive<usize>>(bools: BitBufferView<'_>, indices: &[I]) -> BitBuffer {
     // We dereference to underlying buffer to avoid access cost on every index.
-    let buffer = bools.inner().as_ref();
+    let buffer = bools.inner();
     BitBuffer::collect_bool(indices.len(), |idx| {
         // SAFETY: we can take from the indices unchecked since collect_bool just iterates len.
         let idx = unsafe { indices.get_unchecked(idx).as_() };
diff --git a/vortex-array/src/arrays/bool/compute/zip.rs b/vortex-array/src/arrays/bool/compute/zip.rs
new file mode 100644
index 00000000000..2628b457a85
--- /dev/null
+++ b/vortex-array/src/arrays/bool/compute/zip.rs
@@ -0,0 +1,188 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_buffer::BitBuffer;
+use vortex_buffer::BufferMut;
+use vortex_error::VortexResult;
+use vortex_mask::Mask;
+
+use crate::ArrayRef;
+use crate::ExecutionCtx;
+use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Bool;
+use crate::arrays::BoolArray;
+use crate::arrays::bool::BoolArrayExt;
+use crate::scalar_fn::fns::zip::ZipKernel;
+use crate::scalar_fn::fns::zip::zip_validity;
+
+/// A branchless boolean zip kernel that blends the two value bitmaps with the mask in one pass.
+///
+/// Booleans are bit-packed, so selecting `if_true` where the mask is set and `if_false` where it is
+/// not is a single bitwise blend over the packed words — `(true & mask) | (false & !mask)` — instead
+/// of the generic per-run builder. Validity is combined with the shared `zip_validity`, which itself
+/// reuses this kernel (terminating immediately, since validity bitmaps are non-nullable).
+impl ZipKernel for Bool {
+    fn zip(
+        if_true: ArrayView<'_, Bool>,
+        if_false: &ArrayRef,
+        mask: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        let Some(if_false) = if_false.as_opt::<Bool>() else {
+            return Ok(None);
+        };
+
+        // Null mask entries select `if_false`, matching `Zip`'s SQL ELSE semantics.
+        let mask = mask.try_to_mask_fill_null_false(ctx)?;
+        let mask_values = match &mask {
+            // Defer trivial masks to the generic zip, which just casts the surviving side.
+            Mask::AllTrue(_) | Mask::AllFalse(_) => return Ok(None),
+            Mask::Values(values) => values,
+        };
+        let mask_bits = mask_values.bit_buffer();
+
+        let values = zip_value_bits(
+            &if_true.to_bit_buffer(),
+            &if_false.to_bit_buffer(),
+            mask_bits,
+        );
+
+        let validity = zip_validity(if_true.validity()?, if_false.validity()?, &mask)?;
+
+        Ok(Some(BoolArray::new(values, validity).into_array()))
+    }
+}
+
+fn zip_value_bits(if_true: &BitBuffer, if_false: &BitBuffer, mask: &BitBuffer) -> BitBuffer {
+    assert_eq!(if_true.len(), if_false.len());
+    assert_eq!(if_true.len(), mask.len());
+
+    let true_chunks = if_true.chunks();
+    let false_chunks = if_false.chunks();
+    let mask_chunks = mask.chunks();
+
+    let mut values = BufferMut::<u64>::with_capacity(true_chunks.num_u64s());
+    for ((true_bits, false_bits), mask_bits) in true_chunks
+        .iter()
+        .zip(false_chunks.iter())
+        .zip(mask_chunks.iter())
+    {
+        values.push((true_bits & mask_bits) | (false_bits & !mask_bits));
+    }
+
+    if true_chunks.remainder_len() != 0 {
+        let true_bits = true_chunks.remainder_bits();
+        let false_bits = false_chunks.remainder_bits();
+        let mask_bits = mask_chunks.remainder_bits();
+        values.push((true_bits & mask_bits) | (false_bits & !mask_bits));
+    }
+
+    BitBuffer::new(values.freeze().into_byte_buffer(), if_true.len())
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_error::VortexResult;
+    use vortex_mask::Mask;
+
+    use super::zip_value_bits;
+    use crate::ArrayRef;
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::arrays::Bool;
+    use crate::arrays::BoolArray;
+    use crate::assert_arrays_eq;
+    use crate::builtins::ArrayBuiltins;
+
+    #[test]
+    fn blend_value_bits_boundaries() {
+        for len in [0usize, 1, 2, 7, 8, 9, 63, 64, 65, 127, 128] {
+            let if_true = (0..len).map(|i| i.is_multiple_of(2)).collect();
+            let if_false = (0..len).map(|i| i.is_multiple_of(3)).collect();
+            let mask = (0..len).map(|i| i % 3 != 1).collect();
+
+            let values = zip_value_bits(&if_true, &if_false, &mask);
+
+            assert_eq!(values.len(), len);
+            assert_eq!(
+                values.iter().collect::<Vec<_>>(),
+                (0..len)
+                    .map(|i| {
+                        if i % 3 != 1 {
+                            i.is_multiple_of(2)
+                        } else {
+                            i.is_multiple_of(3)
+                        }
+                    })
+                    .collect::<Vec<_>>(),
+                "failed for len {len}",
+            );
+        }
+    }
+
+    /// Blend two non-nullable bool arrays across the 64-bit mask chunk boundary + remainder.
+    #[test]
+    fn zip_nonnull_spans_mask_chunks() -> VortexResult<()> {
+        let len = 150usize;
+        let if_true = BoolArray::from_iter((0..len).map(|i| i.is_multiple_of(2))).into_array();
+        let if_false = BoolArray::from_iter((0..len).map(|i| i.is_multiple_of(3))).into_array();
+
+        let bits: Vec<bool> = (0..len).map(|i| i.is_multiple_of(5) || i == 64).collect();
+        let mask = Mask::from_iter(bits.iter().copied());
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let result = mask
+            .into_array()
+            .zip(if_true, if_false)?
+            .execute::<ArrayRef>(&mut ctx)?;
+        assert!(result.is::<Bool>());
+
+        let expected = BoolArray::from_iter((0..len).map(|i| {
+            if bits[i] {
+                i.is_multiple_of(2)
+            } else {
+                i.is_multiple_of(3)
+            }
+        }))
+        .into_array();
+        assert_arrays_eq!(result, expected);
+        Ok(())
+    }
+
+    /// With `Validity::Array` on both sides, select values and validity from the chosen side.
+    #[test]
+    fn zip_nullable_selects_values_and_validity() -> VortexResult<()> {
+        let len = 130usize;
+        let if_true = BoolArray::from_iter(
+            (0..len).map(|i| (!i.is_multiple_of(4)).then_some(i.is_multiple_of(2))),
+        )
+        .into_array();
+        let if_false = BoolArray::from_iter(
+            (0..len).map(|i| (!i.is_multiple_of(5)).then_some(i.is_multiple_of(3))),
+        )
+        .into_array();
+
+        let bits: Vec<bool> = (0..len).map(|i| i.is_multiple_of(2)).collect();
+        let mask = Mask::from_iter(bits.iter().copied());
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let result = mask
+            .into_array()
+            .zip(if_true, if_false)?
+            .execute::<ArrayRef>(&mut ctx)?;
+        assert!(result.is::<Bool>());
+
+        let expected = BoolArray::from_iter((0..len).map(|i| {
+            if bits[i] {
+                (!i.is_multiple_of(4)).then_some(i.is_multiple_of(2))
+            } else {
+                (!i.is_multiple_of(5)).then_some(i.is_multiple_of(3))
+            }
+        }))
+        .into_array();
+        assert_arrays_eq!(result, expected);
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/arrays/bool/patch.rs b/vortex-array/src/arrays/bool/patch.rs
index fef03bc30fb..5efdac30231 100644
--- a/vortex-array/src/arrays/bool/patch.rs
+++ b/vortex-array/src/arrays/bool/patch.rs
@@ -31,7 +31,7 @@ impl BoolArray {
             for (idx, value) in indices
                 .as_slice::<I>()
                 .iter()
-                .zip_eq(values.to_bit_buffer().iter())
+                .zip_eq(values.bit_buffer_view().iter())
             {
                 #[allow(clippy::cast_possible_truncation)]
                 own_values.set_to(*idx as usize - offset, value);
diff --git a/vortex-array/src/arrays/bool/vtable/kernel.rs b/vortex-array/src/arrays/bool/vtable/kernel.rs
index 4f1047a5132..2fe2d974a8f 100644
--- a/vortex-array/src/arrays/bool/vtable/kernel.rs
+++ b/vortex-array/src/arrays/bool/vtable/kernel.rs
@@ -6,9 +6,11 @@ use crate::arrays::dict::TakeExecuteAdaptor;
 use crate::kernel::ParentKernelSet;
 use crate::scalar_fn::fns::cast::CastExecuteAdaptor;
 use crate::scalar_fn::fns::fill_null::FillNullExecuteAdaptor;
+use crate::scalar_fn::fns::zip::ZipExecuteAdaptor;
 
 pub(super) const PARENT_KERNELS: ParentKernelSet<Bool> = ParentKernelSet::new(&[
     ParentKernelSet::lift(&CastExecuteAdaptor(Bool)),
     ParentKernelSet::lift(&FillNullExecuteAdaptor(Bool)),
     ParentKernelSet::lift(&TakeExecuteAdaptor(Bool)),
+    ParentKernelSet::lift(&ZipExecuteAdaptor(Bool)),
 ]);
diff --git a/vortex-array/src/arrays/bool/vtable/mod.rs b/vortex-array/src/arrays/bool/vtable/mod.rs
index 35261fa8d89..1bbc091b010 100644
--- a/vortex-array/src/arrays/bool/vtable/mod.rs
+++ b/vortex-array/src/arrays/bool/vtable/mod.rs
@@ -34,7 +34,7 @@ mod validity;
 
 use vortex_session::registry::CachedId;
 
-use crate::Precision;
+use crate::EqMode;
 use crate::array::ArrayId;
 use crate::arrays::bool::compute::rules::RULES;
 use crate::hash::ArrayEq;
@@ -51,15 +51,15 @@ pub struct BoolMetadata {
 }
 
 impl ArrayHash for BoolData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
-        self.bits.array_hash(state, precision);
-        self.offset.hash(state);
+    fn array_hash<H: Hasher>(&self, state: &mut H, accuracy: EqMode) {
+        self.bits.array_hash(state, accuracy);
+        self.meta.offset().hash(state);
     }
 }
 
 impl ArrayEq for BoolData {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
-        self.offset == other.offset && self.bits.array_eq(&other.bits, precision)
+    fn array_eq(&self, other: &Self, accuracy: EqMode) -> bool {
+        self.meta.offset() == other.meta.offset() && self.bits.array_eq(&other.bits, accuracy)
     }
 }
 
@@ -96,10 +96,11 @@ impl VTable for Bool {
         array: ArrayView<'_, Self>,
         _session: &VortexSession,
     ) -> VortexResult<Option<Vec<u8>>> {
-        assert!(array.offset < 8, "Offset must be <8, got {}", array.offset);
+        let offset = array.meta.offset();
+        assert!(offset < 8, "Offset must be <8, got {offset}");
         Ok(Some(
             BoolMetadata {
-                offset: u32::try_from(array.offset).vortex_expect("checked"),
+                offset: u32::try_from(offset).vortex_expect("checked"),
             }
             .encode_to_vec(),
         ))
@@ -116,9 +117,9 @@ impl VTable for Bool {
             vortex_bail!("Expected bool dtype, got {dtype:?}");
         };
         vortex_ensure!(
-            data.bits.len() * 8 >= data.offset + len,
+            data.bits.len() * 8 >= data.meta.offset() + len,
             "BoolArray buffer with offset {} cannot back outer length {} (buffer bits = {})",
-            data.offset,
+            data.meta.offset(),
             len,
             data.bits.len() * 8
         );
diff --git a/vortex-array/src/arrays/bool/vtable/operations.rs b/vortex-array/src/arrays/bool/vtable/operations.rs
index 11147b810b2..b4ac4682d23 100644
--- a/vortex-array/src/arrays/bool/vtable/operations.rs
+++ b/vortex-array/src/arrays/bool/vtable/operations.rs
@@ -17,7 +17,7 @@ impl OperationsVTable<Bool> for Bool {
         _ctx: &mut ExecutionCtx,
     ) -> VortexResult<Scalar> {
         Ok(Scalar::bool(
-            array.to_bit_buffer().value(index),
+            array.bit_buffer_view().value(index),
             array.dtype().nullability(),
         ))
     }
diff --git a/vortex-array/src/arrays/chunked/compute/rules.rs b/vortex-array/src/arrays/chunked/compute/rules.rs
index d8d324a8e86..712578255bb 100644
--- a/vortex-array/src/arrays/chunked/compute/rules.rs
+++ b/vortex-array/src/arrays/chunked/compute/rules.rs
@@ -48,13 +48,9 @@ impl ArrayParentReduceRule<Chunked> for ChunkedUnaryScalarFnPushDownRule {
         let new_chunks: Vec<_> = array
             .iter_chunks()
             .map(|chunk| {
-                ScalarFnArray::try_new(
-                    parent.scalar_fn().clone(),
-                    vec![chunk.clone()],
-                    chunk.len(),
-                )?
-                .into_array()
-                .optimize()
+                ScalarFnArray::try_new(parent.scalar_fn().clone(), vec![chunk.clone()])?
+                    .into_array()
+                    .optimize()
             })
             .try_collect()?;
 
@@ -104,7 +100,7 @@ impl ArrayParentReduceRule<Chunked> for ChunkedConstantScalarFnPushDownRule {
                     })
                     .collect();
 
-                ScalarFnArray::try_new(parent.scalar_fn().clone(), new_children, chunk.len())?
+                ScalarFnArray::try_new(parent.scalar_fn().clone(), new_children)?
                     .into_array()
                     .optimize()
             })
diff --git a/vortex-array/src/arrays/chunked/vtable/canonical.rs b/vortex-array/src/arrays/chunked/vtable/canonical.rs
index 6da34e3cb07..adbe447604b 100644
--- a/vortex-array/src/arrays/chunked/vtable/canonical.rs
+++ b/vortex-array/src/arrays/chunked/vtable/canonical.rs
@@ -78,7 +78,7 @@ pub(super) fn _canonicalize(
     })
 }
 
-/// Packs many [`StructArray`]s to instead be a single [`StructArray`], where the [`DynArrayData`] for each
+/// Packs many [`StructArray`]s to instead be a single [`StructArray`], where the [`DynArrayData`](crate::array::DynArrayData) for each
 /// field is a [`ChunkedArray`].
 ///
 /// The caller guarantees there are at least 2 chunks.
@@ -188,7 +188,7 @@ fn swizzle_list_chunks(
         let chunk_array = chunk.clone().execute::<ListViewArray>(ctx)?;
         // By rebuilding as zero-copy to `List` and trimming all elements (to prevent gaps), we make
         // the final output `ListView` also zero-copyable to `List`.
-        let chunk_array = chunk_array.rebuild(ListViewRebuildMode::MakeExact)?;
+        let chunk_array = chunk_array.rebuild(ListViewRebuildMode::MakeExact, ctx)?;
 
         // Add the `elements` of the current array as a new chunk.
         list_elements_chunks.push(chunk_array.elements().clone());
@@ -285,6 +285,7 @@ fn swizzle_fixed_size_list_chunks(
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;
+    use std::sync::LazyLock;
     use std::sync::atomic::AtomicUsize;
     use std::sync::atomic::Ordering;
 
@@ -298,15 +299,13 @@ mod tests {
     use crate::Canonical;
     use crate::ExecutionCtx;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
-    #[expect(deprecated)]
-    use crate::ToCanonical as _;
     use crate::VortexSessionExecute;
     use crate::accessor::ArrayAccessor;
     use crate::arrays::ChunkedArray;
     use crate::arrays::ConstantArray;
     use crate::arrays::FixedSizeListArray;
     use crate::arrays::ListArray;
+    use crate::arrays::ListViewArray;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::StructArray;
     use crate::arrays::VarBinViewArray;
@@ -324,8 +323,13 @@ mod tests {
     use crate::memory::MemorySessionExt;
     use crate::memory::WritableHostBuffer;
     use crate::scalar::Scalar;
+    use crate::session::ArraySession;
     use crate::validity::Validity;
 
+    /// A shared session for these chunked-array tests, used to create execution contexts.
+    static SESSION: LazyLock<VortexSession> =
+        LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
     #[derive(Debug)]
     struct CountingAllocator {
         allocations: Arc<AtomicUsize>,
@@ -375,7 +379,7 @@ mod tests {
 
     fn assert_variant_values(array: &VariantArray, expected: &[i32]) -> VortexResult<()> {
         assert_eq!(array.len(), expected.len());
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
 
         for (idx, expected) in expected.iter().copied().enumerate() {
             let scalar = array.execute_scalar(idx, &mut ctx)?;
@@ -391,6 +395,7 @@ mod tests {
 
     #[test]
     fn pack_variant_chunks_without_shredded() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
         let chunked = ChunkedArray::try_new(
             vec![
                 variant_chunk([1, 2])?.into_array(),
@@ -400,9 +405,7 @@ mod tests {
         )?
         .into_array();
 
-        let variant = into_variant(
-            chunked.execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())?,
-        )?;
+        let variant = into_variant(chunked.execute::<Canonical>(&mut ctx)?)?;
 
         assert_eq!(variant.len(), 3);
         assert!(variant.shredded().is_none());
@@ -411,6 +414,7 @@ mod tests {
 
     #[test]
     fn pack_variant_chunks_all_shredded_same_dtype() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
         let chunked = ChunkedArray::try_new(
             vec![
                 variant_chunk_with_shredded(
@@ -425,9 +429,7 @@ mod tests {
         )?
         .into_array();
 
-        let variant = into_variant(
-            chunked.execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())?,
-        )?;
+        let variant = into_variant(chunked.execute::<Canonical>(&mut ctx)?)?;
         let shredded = variant
             .shredded()
             .ok_or_else(|| vortex_err!("expected shredded child"))?;
@@ -436,15 +438,14 @@ mod tests {
         assert_eq!(shredded.len(), 3);
         assert_variant_values(&variant, &[10, 20, 30])?;
 
-        let shredded = shredded
-            .clone()
-            .execute::<PrimitiveArray>(&mut LEGACY_SESSION.create_execution_ctx())?;
+        let shredded = shredded.clone().execute::<PrimitiveArray>(&mut ctx)?;
         assert_arrays_eq!(shredded, PrimitiveArray::from_iter([10i32, 20, 30]));
         Ok(())
     }
 
     #[test]
     fn pack_variant_chunks_mixed_shredded_presence_errors() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
         let chunked = ChunkedArray::try_new(
             vec![
                 variant_chunk_with_shredded([1], PrimitiveArray::from_iter([10i32]).into_array())?
@@ -455,9 +456,7 @@ mod tests {
         )?
         .into_array();
 
-        let err = chunked
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap_err();
+        let err = chunked.execute::<Canonical>(&mut ctx).unwrap_err();
         assert!(
             err.to_string()
                 .contains("chunks disagree on shredded presence")
@@ -467,6 +466,7 @@ mod tests {
 
     #[test]
     fn pack_variant_chunks_mismatched_shredded_dtype_errors() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
         let chunked = ChunkedArray::try_new(
             vec![
                 variant_chunk_with_shredded([1], PrimitiveArray::from_iter([10i32]).into_array())?
@@ -478,20 +478,17 @@ mod tests {
         )?
         .into_array();
 
-        let err = chunked
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap_err();
+        let err = chunked.execute::<Canonical>(&mut ctx).unwrap_err();
         assert!(err.to_string().contains("shredded dtype mismatch"));
         Ok(())
     }
 
     #[test]
     fn pack_variant_chunks_empty() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
         let chunked = ChunkedArray::try_new(vec![], VariantDType(NonNullable))?.into_array();
 
-        let variant = into_variant(
-            chunked.execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())?,
-        )?;
+        let variant = into_variant(chunked.execute::<Canonical>(&mut ctx)?)?;
 
         assert_eq!(variant.len(), 0);
         assert!(variant.shredded().is_none());
@@ -500,6 +497,7 @@ mod tests {
 
     #[test]
     fn pack_variant_chunks_single_chunk() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
         let chunked = ChunkedArray::try_new(
             vec![
                 variant_chunk_with_shredded(
@@ -512,9 +510,7 @@ mod tests {
         )?
         .into_array();
 
-        let variant = into_variant(
-            chunked.execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())?,
-        )?;
+        let variant = into_variant(chunked.execute::<Canonical>(&mut ctx)?)?;
 
         assert_eq!(variant.len(), 2);
         assert!(variant.shredded().is_some());
@@ -523,6 +519,7 @@ mod tests {
 
     #[test]
     pub fn pack_nested_structs() {
+        let mut ctx = SESSION.create_execution_ctx();
         let struct_array = StructArray::try_new(
             ["a"].into(),
             vec![VarBinViewArray::from_iter_str(["foo", "bar", "baz", "quak"]).into_array()],
@@ -541,12 +538,17 @@ mod tests {
         )
         .unwrap()
         .into_array();
-        #[expect(deprecated)]
-        let canonical_struct = chunked.to_struct();
-        #[expect(deprecated)]
-        let canonical_varbin = canonical_struct.unmasked_field(0).to_varbinview();
-        #[expect(deprecated)]
-        let original_varbin = struct_array.unmasked_field(0).to_varbinview();
+        let canonical_struct = chunked.execute::<StructArray>(&mut ctx).unwrap();
+        let canonical_varbin = canonical_struct
+            .unmasked_field(0)
+            .clone()
+            .execute::<VarBinViewArray>(&mut ctx)
+            .unwrap();
+        let original_varbin = struct_array
+            .unmasked_field(0)
+            .clone()
+            .execute::<VarBinViewArray>(&mut ctx)
+            .unwrap();
         let orig_values = original_varbin
             .with_iterator(|it| it.map(|a| a.map(|v| v.to_vec())).collect::<Vec<_>>());
         let canon_values = canonical_varbin
@@ -556,6 +558,7 @@ mod tests {
 
     #[test]
     pub fn pack_nested_lists() {
+        let mut ctx = SESSION.create_execution_ctx();
         let l1 = ListArray::try_new(
             buffer![1, 2, 3, 4].into_array(),
             buffer![0, 3].into_array(),
@@ -575,27 +578,26 @@ mod tests {
             List(Arc::new(Primitive(I32, NonNullable)), NonNullable),
         );
 
-        #[expect(deprecated)]
-        let canon_values = chunked_list.unwrap().as_array().to_listview();
+        let canon_values = chunked_list
+            .unwrap()
+            .as_array()
+            .clone()
+            .execute::<ListViewArray>(&mut ctx)
+            .unwrap();
 
         assert_eq!(
-            l1.execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
-                .unwrap(),
-            canon_values
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
-                .unwrap()
+            l1.execute_scalar(0, &mut ctx).unwrap(),
+            canon_values.execute_scalar(0, &mut ctx).unwrap()
         );
         assert_eq!(
-            l2.execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
-                .unwrap(),
-            canon_values
-                .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
-                .unwrap()
+            l2.execute_scalar(0, &mut ctx).unwrap(),
+            canon_values.execute_scalar(1, &mut ctx).unwrap()
         );
     }
 
     #[test]
     fn pack_fixed_size_lists() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
         let f1 = FixedSizeListArray::try_new(
             buffer![1, 2, 3, 4, 5, 6].into_array(),
             2,
@@ -613,9 +615,7 @@ mod tests {
         let chunked =
             ChunkedArray::try_new(vec![f1.into_array(), f2.into_array()], dtype)?.into_array();
 
-        let canonical = chunked
-            .clone()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())?;
+        let canonical = chunked.clone().execute::<Canonical>(&mut ctx)?;
         let fsl = match canonical {
             Canonical::FixedSizeList(fsl) => fsl,
             other => vortex_bail!("expected FixedSizeList canonical array, got {other:?}"),
@@ -630,8 +630,8 @@ mod tests {
         )?;
         for idx in 0..5 {
             assert_eq!(
-                chunked.execute_scalar(idx, &mut LEGACY_SESSION.create_execution_ctx())?,
-                expected.execute_scalar(idx, &mut LEGACY_SESSION.create_execution_ctx())?,
+                chunked.execute_scalar(idx, &mut ctx)?,
+                expected.execute_scalar(idx, &mut ctx)?,
             );
         }
         Ok(())
diff --git a/vortex-array/src/arrays/chunked/vtable/mod.rs b/vortex-array/src/arrays/chunked/vtable/mod.rs
index 68679a4c3b5..a70ba6869ab 100644
--- a/vortex-array/src/arrays/chunked/vtable/mod.rs
+++ b/vortex-array/src/arrays/chunked/vtable/mod.rs
@@ -18,10 +18,10 @@ use crate::ArrayEq;
 use crate::ArrayHash;
 use crate::ArrayRef;
 use crate::Canonical;
+use crate::EqMode;
 use crate::ExecutionCtx;
 use crate::ExecutionResult;
 use crate::IntoArray;
-use crate::Precision;
 #[expect(deprecated)]
 use crate::ToCanonical as _;
 use crate::array::Array;
@@ -53,14 +53,14 @@ pub type ChunkedArray = Array<Chunked>;
 pub struct Chunked;
 
 impl ArrayHash for ChunkedData {
-    fn array_hash<H: Hasher>(&self, _state: &mut H, _precision: Precision) {
+    fn array_hash<H: Hasher>(&self, _state: &mut H, _accuracy: EqMode) {
         // Chunk offsets are cached derived data. Slot 0 already stores the logical offsets array,
         // and ArrayData hashing includes every slot before TypedArrayData.
     }
 }
 
 impl ArrayEq for ChunkedData {
-    fn array_eq(&self, _other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, _other: &Self, _accuracy: EqMode) -> bool {
         // Chunk offsets are cached derived data. Slot 0 already stores the logical offsets array,
         // and ArrayData equality compares every slot before TypedArrayData.
         true
diff --git a/vortex-array/src/arrays/constant/vtable/canonical.rs b/vortex-array/src/arrays/constant/vtable/canonical.rs
index 53dcd3d262d..dd891778949 100644
--- a/vortex-array/src/arrays/constant/vtable/canonical.rs
+++ b/vortex-array/src/arrays/constant/vtable/canonical.rs
@@ -330,25 +330,30 @@ fn constant_canonical_fixed_size_list_array(
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;
+    use std::sync::LazyLock;
 
     use enum_iterator::all;
     use itertools::Itertools;
     use vortex_error::VortexExpect;
     use vortex_error::VortexResult;
+    use vortex_session::VortexSession;
 
+    use crate::Canonical;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::arrays::ConstantArray;
+    use crate::arrays::FixedSizeListArray;
+    use crate::arrays::ListViewArray;
+    use crate::arrays::NullArray;
     use crate::arrays::PrimitiveArray;
+    use crate::arrays::StructArray;
     use crate::arrays::VarBinArray;
+    use crate::arrays::VarBinViewArray;
     use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
     use crate::arrays::listview::ListViewArrayExt;
     use crate::arrays::listview::ListViewRebuildMode;
     use crate::arrays::struct_::StructArrayExt;
     use crate::assert_arrays_eq;
-    #[expect(deprecated)]
-    use crate::canonical::ToCanonical as _;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
     use crate::dtype::PType;
@@ -356,18 +361,25 @@ mod tests {
     use crate::expr::stats::Stat;
     use crate::expr::stats::StatsProvider;
     use crate::scalar::Scalar;
+    use crate::session::ArraySession;
     use crate::validity::Validity;
 
+    /// A shared session for these constant-array tests, used to create execution contexts.
+    static SESSION: LazyLock<VortexSession> =
+        LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
     #[test]
     fn test_canonicalize_null() {
+        let mut ctx = SESSION.create_execution_ctx();
         let const_null = ConstantArray::new(Scalar::null(DType::Null), 42);
-        #[expect(deprecated)]
-        let actual = const_null.as_array().to_null();
+        let actual = const_null
+            .as_array()
+            .clone()
+            .execute::<NullArray>(&mut ctx)
+            .unwrap();
         assert_eq!(actual.len(), 42);
         assert_eq!(
-            actual
-                .execute_scalar(33, &mut LEGACY_SESSION.create_execution_ctx())
-                .unwrap(),
+            actual.execute_scalar(33, &mut ctx).unwrap(),
             Scalar::null(DType::Null)
         );
     }
@@ -382,14 +394,13 @@ mod tests {
 
     #[test]
     fn test_canonicalize_propagates_stats() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
         let scalar = Scalar::bool(true, Nullability::NonNullable);
         let const_array = ConstantArray::new(scalar, 4).into_array();
-        let stats = const_array.statistics().compute_all(
-            &all::<Stat>().collect_vec(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
-        )?;
-        #[expect(deprecated)]
-        let canonical = const_array.to_canonical()?.into_array();
+        let stats = const_array
+            .statistics()
+            .compute_all(&all::<Stat>().collect_vec(), &mut ctx)?;
+        let canonical = const_array.execute::<Canonical>(&mut ctx)?.into_array();
         let canonical_stats = canonical.statistics();
 
         let stats_ref = stats.as_typed_ref(canonical.dtype());
@@ -409,47 +420,52 @@ mod tests {
 
     #[test]
     fn test_canonicalize_scalar_values() {
+        let mut ctx = SESSION.create_execution_ctx();
         let f16_value = f16::from_f32(5.722046e-6);
         let f16_scalar = Scalar::primitive(f16_value, Nullability::NonNullable);
 
         // Create a ConstantArray with the f16 scalar
         let const_array = ConstantArray::new(f16_scalar.clone(), 1).into_array();
-        #[expect(deprecated)]
-        let canonical_const = const_array.to_primitive();
+        let canonical_const = const_array.execute::<PrimitiveArray>(&mut ctx).unwrap();
 
         // Verify the scalar value is preserved through canonicalization
         assert_eq!(
-            canonical_const
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
-                .unwrap(),
+            canonical_const.execute_scalar(0, &mut ctx).unwrap(),
             f16_scalar
         );
     }
 
     #[test]
     fn test_canonicalize_lists() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
         let list_scalar = Scalar::list(
             Arc::new(DType::Primitive(PType::U64, Nullability::NonNullable)),
             vec![1u64.into(), 2u64.into()],
             Nullability::NonNullable,
         );
         let const_array = ConstantArray::new(list_scalar, 2).into_array();
-        #[expect(deprecated)]
-        let canonical_const = const_array.to_listview();
-        let list_array = canonical_const.rebuild(ListViewRebuildMode::MakeZeroCopyToList)?;
+        let canonical_const = const_array.execute::<ListViewArray>(&mut ctx)?;
+        let list_array =
+            canonical_const.rebuild(ListViewRebuildMode::MakeZeroCopyToList, &mut ctx)?;
         assert_arrays_eq!(
-            #[expect(deprecated)]
-            list_array.elements().to_primitive(),
+            list_array
+                .elements()
+                .clone()
+                .execute::<PrimitiveArray>(&mut ctx)?,
             PrimitiveArray::from_iter([1u64, 2, 1, 2])
         );
         assert_arrays_eq!(
-            #[expect(deprecated)]
-            list_array.offsets().to_primitive(),
+            list_array
+                .offsets()
+                .clone()
+                .execute::<PrimitiveArray>(&mut ctx)?,
             PrimitiveArray::from_iter([0u64, 2])
         );
         assert_arrays_eq!(
-            #[expect(deprecated)]
-            list_array.sizes().to_primitive(),
+            list_array
+                .sizes()
+                .clone()
+                .execute::<PrimitiveArray>(&mut ctx)?,
             PrimitiveArray::from_iter([2u64, 2])
         );
         Ok(())
@@ -457,55 +473,74 @@ mod tests {
 
     #[test]
     fn test_canonicalize_empty_list() {
+        let mut ctx = SESSION.create_execution_ctx();
         let list_scalar = Scalar::list(
             Arc::new(DType::Primitive(PType::U64, Nullability::NonNullable)),
             vec![],
             Nullability::NonNullable,
         );
         let const_array = ConstantArray::new(list_scalar, 2).into_array();
-        #[expect(deprecated)]
-        let canonical_const = const_array.to_listview();
-        #[expect(deprecated)]
-        let elements_prim = canonical_const.elements().to_primitive();
+        let canonical_const = const_array.execute::<ListViewArray>(&mut ctx).unwrap();
+        let elements_prim = canonical_const
+            .elements()
+            .clone()
+            .execute::<PrimitiveArray>(&mut ctx)
+            .unwrap();
         assert!(elements_prim.is_empty());
         assert_arrays_eq!(
-            #[expect(deprecated)]
-            canonical_const.offsets().to_primitive(),
+            canonical_const
+                .offsets()
+                .clone()
+                .execute::<PrimitiveArray>(&mut ctx)
+                .unwrap(),
             PrimitiveArray::from_iter([0u64, 0])
         );
         assert_arrays_eq!(
-            #[expect(deprecated)]
-            canonical_const.sizes().to_primitive(),
+            canonical_const
+                .sizes()
+                .clone()
+                .execute::<PrimitiveArray>(&mut ctx)
+                .unwrap(),
             PrimitiveArray::from_iter([0u64, 0])
         );
     }
 
     #[test]
     fn test_canonicalize_null_list() {
+        let mut ctx = SESSION.create_execution_ctx();
         let list_scalar = Scalar::null(DType::List(
             Arc::new(DType::Primitive(PType::U64, Nullability::NonNullable)),
             Nullability::Nullable,
         ));
         let const_array = ConstantArray::new(list_scalar, 2).into_array();
-        #[expect(deprecated)]
-        let canonical_const = const_array.to_listview();
-        #[expect(deprecated)]
-        let elements_prim = canonical_const.elements().to_primitive();
+        let canonical_const = const_array.execute::<ListViewArray>(&mut ctx).unwrap();
+        let elements_prim = canonical_const
+            .elements()
+            .clone()
+            .execute::<PrimitiveArray>(&mut ctx)
+            .unwrap();
         assert!(elements_prim.is_empty());
         assert_arrays_eq!(
-            #[expect(deprecated)]
-            canonical_const.offsets().to_primitive(),
+            canonical_const
+                .offsets()
+                .clone()
+                .execute::<PrimitiveArray>(&mut ctx)
+                .unwrap(),
             PrimitiveArray::from_iter([0u64, 0])
         );
         assert_arrays_eq!(
-            #[expect(deprecated)]
-            canonical_const.sizes().to_primitive(),
+            canonical_const
+                .sizes()
+                .clone()
+                .execute::<PrimitiveArray>(&mut ctx)
+                .unwrap(),
             PrimitiveArray::from_iter([0u64, 0])
         );
     }
 
     #[test]
     fn test_canonicalize_nullable_struct() {
+        let mut ctx = SESSION.create_execution_ctx();
         let array = ConstantArray::new(
             Scalar::null(DType::struct_(
                 [(
@@ -517,15 +552,13 @@ mod tests {
             3,
         );
 
-        #[expect(deprecated)]
-        let struct_array = array.as_array().to_struct();
+        let struct_array = array
+            .as_array()
+            .clone()
+            .execute::<StructArray>(&mut ctx)
+            .unwrap();
         assert_eq!(struct_array.len(), 3);
-        assert_eq!(
-            struct_array
-                .valid_count(&mut LEGACY_SESSION.create_execution_ctx())
-                .unwrap(),
-            0
-        );
+        assert_eq!(struct_array.valid_count(&mut ctx).unwrap(), 0);
 
         let field = struct_array
             .unmasked_field_by_name("non_null_field")
@@ -539,6 +572,7 @@ mod tests {
 
     #[test]
     fn test_canonicalize_fixed_size_list_non_null() {
+        let mut ctx = SESSION.create_execution_ctx();
         // Test with a non-null fixed-size list constant.
         let fsl_scalar = Scalar::fixed_size_list(
             Arc::new(DType::Primitive(PType::I32, Nullability::NonNullable)),
@@ -551,8 +585,7 @@ mod tests {
         );
 
         let const_array = ConstantArray::new(fsl_scalar, 4).into_array();
-        #[expect(deprecated)]
-        let canonical = const_array.to_fixed_size_list();
+        let canonical = const_array.execute::<FixedSizeListArray>(&mut ctx).unwrap();
 
         assert_eq!(canonical.len(), 4);
         assert_eq!(canonical.list_size(), 3);
@@ -561,14 +594,14 @@ mod tests {
         // Check that each list is [10, 20, 30].
         for i in 0..4 {
             let list = canonical.fixed_size_list_elements_at(i).unwrap();
-            #[expect(deprecated)]
-            let list_primitive = list.to_primitive();
+            let list_primitive = list.execute::<PrimitiveArray>(&mut ctx).unwrap();
             assert_arrays_eq!(list_primitive, PrimitiveArray::from_iter([10i32, 20, 30]));
         }
     }
 
     #[test]
     fn test_canonicalize_fixed_size_list_nullable() {
+        let mut ctx = SESSION.create_execution_ctx();
         // Test with a nullable but non-null fixed-size list constant.
         let fsl_scalar = Scalar::fixed_size_list(
             Arc::new(DType::Primitive(PType::F64, Nullability::NonNullable)),
@@ -580,16 +613,18 @@ mod tests {
         );
 
         let const_array = ConstantArray::new(fsl_scalar, 3).into_array();
-        #[expect(deprecated)]
-        let canonical = const_array.to_fixed_size_list();
+        let canonical = const_array.execute::<FixedSizeListArray>(&mut ctx).unwrap();
 
         assert_eq!(canonical.len(), 3);
         assert_eq!(canonical.list_size(), 2);
         assert!(matches!(canonical.validity(), Ok(Validity::AllValid)));
 
         // Check elements.
-        #[expect(deprecated)]
-        let elements = canonical.elements().to_primitive();
+        let elements = canonical
+            .elements()
+            .clone()
+            .execute::<PrimitiveArray>(&mut ctx)
+            .unwrap();
         assert_arrays_eq!(
             elements,
             PrimitiveArray::from_iter([1.5f64, 2.5, 1.5, 2.5, 1.5, 2.5])
@@ -598,6 +633,7 @@ mod tests {
 
     #[test]
     fn test_canonicalize_fixed_size_list_null() {
+        let mut ctx = SESSION.create_execution_ctx();
         // Test with a null fixed-size list constant.
         let fsl_scalar = Scalar::null(DType::FixedSizeList(
             Arc::new(DType::Primitive(PType::U64, Nullability::NonNullable)),
@@ -606,22 +642,25 @@ mod tests {
         ));
 
         let const_array = ConstantArray::new(fsl_scalar, 5).into_array();
-        #[expect(deprecated)]
-        let canonical = const_array.to_fixed_size_list();
+        let canonical = const_array.execute::<FixedSizeListArray>(&mut ctx).unwrap();
 
         assert_eq!(canonical.len(), 5);
         assert_eq!(canonical.list_size(), 4);
         assert!(matches!(canonical.validity(), Ok(Validity::AllInvalid)));
 
         // Elements should be defaults (zeros).
-        #[expect(deprecated)]
-        let elements = canonical.elements().to_primitive();
+        let elements = canonical
+            .elements()
+            .clone()
+            .execute::<PrimitiveArray>(&mut ctx)
+            .unwrap();
         assert_eq!(elements.len(), 20); // 5 lists * 4 elements each
         assert!(elements.as_slice::<u64>().iter().all(|&x| x == 0));
     }
 
     #[test]
     fn test_canonicalize_fixed_size_list_empty() {
+        let mut ctx = SESSION.create_execution_ctx();
         // Test with size-0 lists (edge case).
         let fsl_scalar = Scalar::fixed_size_list(
             Arc::new(DType::Primitive(PType::I8, Nullability::NonNullable)),
@@ -630,8 +669,7 @@ mod tests {
         );
 
         let const_array = ConstantArray::new(fsl_scalar, 10).into_array();
-        #[expect(deprecated)]
-        let canonical = const_array.to_fixed_size_list();
+        let canonical = const_array.execute::<FixedSizeListArray>(&mut ctx).unwrap();
 
         assert_eq!(canonical.len(), 10);
         assert_eq!(canonical.list_size(), 0);
@@ -643,6 +681,7 @@ mod tests {
 
     #[test]
     fn test_canonicalize_fixed_size_list_nested() {
+        let mut ctx = SESSION.create_execution_ctx();
         // Test with nested data types (list of strings).
         let fsl_scalar = Scalar::fixed_size_list(
             Arc::new(DType::Utf8(Nullability::NonNullable)),
@@ -651,43 +690,38 @@ mod tests {
         );
 
         let const_array = ConstantArray::new(fsl_scalar, 2).into_array();
-        #[expect(deprecated)]
-        let canonical = const_array.to_fixed_size_list();
+        let canonical = const_array.execute::<FixedSizeListArray>(&mut ctx).unwrap();
 
         assert_eq!(canonical.len(), 2);
         assert_eq!(canonical.list_size(), 2);
 
         // Check elements are repeated correctly.
-        #[expect(deprecated)]
-        let elements = canonical.elements().to_varbinview();
+        let elements = canonical
+            .elements()
+            .clone()
+            .execute::<VarBinViewArray>(&mut ctx)
+            .unwrap();
         assert_eq!(
-            elements
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
-                .unwrap(),
+            elements.execute_scalar(0, &mut ctx).unwrap(),
             "hello".into()
         );
         assert_eq!(
-            elements
-                .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
-                .unwrap(),
+            elements.execute_scalar(1, &mut ctx).unwrap(),
             "world".into()
         );
         assert_eq!(
-            elements
-                .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
-                .unwrap(),
+            elements.execute_scalar(2, &mut ctx).unwrap(),
             "hello".into()
         );
         assert_eq!(
-            elements
-                .execute_scalar(3, &mut LEGACY_SESSION.create_execution_ctx())
-                .unwrap(),
+            elements.execute_scalar(3, &mut ctx).unwrap(),
             "world".into()
         );
     }
 
     #[test]
     fn test_canonicalize_fixed_size_list_single_element() {
+        let mut ctx = SESSION.create_execution_ctx();
         // Test with a single-element list.
         let fsl_scalar = Scalar::fixed_size_list(
             Arc::new(DType::Primitive(PType::I16, Nullability::NonNullable)),
@@ -696,19 +730,22 @@ mod tests {
         );
 
         let const_array = ConstantArray::new(fsl_scalar, 1).into_array();
-        #[expect(deprecated)]
-        let canonical = const_array.to_fixed_size_list();
+        let canonical = const_array.execute::<FixedSizeListArray>(&mut ctx).unwrap();
 
         assert_eq!(canonical.len(), 1);
         assert_eq!(canonical.list_size(), 1);
 
-        #[expect(deprecated)]
-        let elements = canonical.elements().to_primitive();
+        let elements = canonical
+            .elements()
+            .clone()
+            .execute::<PrimitiveArray>(&mut ctx)
+            .unwrap();
         assert_arrays_eq!(elements, PrimitiveArray::from_iter([42i16]));
     }
 
     #[test]
     fn test_canonicalize_fixed_size_list_with_null_elements() {
+        let mut ctx = SESSION.create_execution_ctx();
         // Test FSL with nullable element type where some elements are null.
         let fsl_scalar = Scalar::fixed_size_list(
             Arc::new(DType::Primitive(PType::I32, Nullability::Nullable)),
@@ -721,32 +758,28 @@ mod tests {
         );
 
         let const_array = ConstantArray::new(fsl_scalar, 3).into_array();
-        #[expect(deprecated)]
-        let canonical = const_array.to_fixed_size_list();
+        let canonical = const_array.execute::<FixedSizeListArray>(&mut ctx).unwrap();
 
         assert_eq!(canonical.len(), 3);
         assert_eq!(canonical.list_size(), 3);
         assert!(matches!(canonical.validity(), Ok(Validity::NonNullable)));
 
         // Check elements including nulls.
-        #[expect(deprecated)]
-        let elements = canonical.elements().to_primitive();
+        let elements = canonical
+            .elements()
+            .clone()
+            .execute::<PrimitiveArray>(&mut ctx)
+            .unwrap();
         assert_eq!(
-            elements
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
-                .unwrap(),
+            elements.execute_scalar(0, &mut ctx).unwrap(),
             Scalar::from(100i32)
         );
         assert_eq!(
-            elements
-                .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
-                .unwrap(),
+            elements.execute_scalar(1, &mut ctx).unwrap(),
             Scalar::null(DType::Primitive(PType::I32, Nullability::Nullable))
         );
         assert_eq!(
-            elements
-                .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
-                .unwrap(),
+            elements.execute_scalar(2, &mut ctx).unwrap(),
             Scalar::from(200i32)
         );
 
@@ -754,18 +787,19 @@ mod tests {
         let element_validity = elements
             .validity()
             .vortex_expect("constant canonical element validity should be derivable");
-        assert!(element_validity.is_valid(0).unwrap());
-        assert!(!element_validity.is_valid(1).unwrap());
-        assert!(element_validity.is_valid(2).unwrap());
+        assert!(element_validity.execute_is_valid(0, &mut ctx).unwrap());
+        assert!(!element_validity.execute_is_valid(1, &mut ctx).unwrap());
+        assert!(element_validity.execute_is_valid(2, &mut ctx).unwrap());
 
         // Pattern should repeat.
-        assert!(element_validity.is_valid(3).unwrap());
-        assert!(!element_validity.is_valid(4).unwrap());
-        assert!(element_validity.is_valid(5).unwrap());
+        assert!(element_validity.execute_is_valid(3, &mut ctx).unwrap());
+        assert!(!element_validity.execute_is_valid(4, &mut ctx).unwrap());
+        assert!(element_validity.execute_is_valid(5, &mut ctx).unwrap());
     }
 
     #[test]
     fn test_canonicalize_fixed_size_list_large() {
+        let mut ctx = SESSION.create_execution_ctx();
         // Test with a large constant array.
         let fsl_scalar = Scalar::fixed_size_list(
             Arc::new(DType::Primitive(PType::U8, Nullability::NonNullable)),
@@ -780,47 +814,39 @@ mod tests {
         );
 
         let const_array = ConstantArray::new(fsl_scalar, 1000).into_array();
-        #[expect(deprecated)]
-        let canonical = const_array.to_fixed_size_list();
+        let canonical = const_array.execute::<FixedSizeListArray>(&mut ctx).unwrap();
 
         assert_eq!(canonical.len(), 1000);
         assert_eq!(canonical.list_size(), 5);
 
-        #[expect(deprecated)]
-        let elements = canonical.elements().to_primitive();
+        let elements = canonical
+            .elements()
+            .clone()
+            .execute::<PrimitiveArray>(&mut ctx)
+            .unwrap();
         assert_eq!(elements.len(), 5000);
 
         // Check pattern repeats correctly.
         for i in 0..1000 {
             let base = i * 5;
             assert_eq!(
-                elements
-                    .execute_scalar(base, &mut LEGACY_SESSION.create_execution_ctx())
-                    .unwrap(),
+                elements.execute_scalar(base, &mut ctx).unwrap(),
                 Scalar::from(1u8)
             );
             assert_eq!(
-                elements
-                    .execute_scalar(base + 1, &mut LEGACY_SESSION.create_execution_ctx())
-                    .unwrap(),
+                elements.execute_scalar(base + 1, &mut ctx).unwrap(),
                 Scalar::from(2u8)
             );
             assert_eq!(
-                elements
-                    .execute_scalar(base + 2, &mut LEGACY_SESSION.create_execution_ctx())
-                    .unwrap(),
+                elements.execute_scalar(base + 2, &mut ctx).unwrap(),
                 Scalar::from(3u8)
             );
             assert_eq!(
-                elements
-                    .execute_scalar(base + 3, &mut LEGACY_SESSION.create_execution_ctx())
-                    .unwrap(),
+                elements.execute_scalar(base + 3, &mut ctx).unwrap(),
                 Scalar::from(4u8)
             );
             assert_eq!(
-                elements
-                    .execute_scalar(base + 4, &mut LEGACY_SESSION.create_execution_ctx())
-                    .unwrap(),
+                elements.execute_scalar(base + 4, &mut ctx).unwrap(),
                 Scalar::from(5u8)
             );
         }
diff --git a/vortex-array/src/arrays/constant/vtable/mod.rs b/vortex-array/src/arrays/constant/vtable/mod.rs
index c130c28a95a..89c571eb827 100644
--- a/vortex-array/src/arrays/constant/vtable/mod.rs
+++ b/vortex-array/src/arrays/constant/vtable/mod.rs
@@ -16,10 +16,10 @@ use vortex_session::registry::CachedId;
 use crate::ArrayEq;
 use crate::ArrayHash;
 use crate::ArrayRef;
+use crate::EqMode;
 use crate::ExecutionCtx;
 use crate::ExecutionResult;
 use crate::IntoArray;
-use crate::Precision;
 use crate::array::Array;
 use crate::array::ArrayId;
 use crate::array::ArrayView;
@@ -53,13 +53,13 @@ pub type ConstantArray = Array<Constant>;
 pub struct Constant;
 
 impl ArrayHash for ConstantData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _accuracy: EqMode) {
         self.scalar.hash(state);
     }
 }
 
 impl ArrayEq for ConstantData {
-    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, _accuracy: EqMode) -> bool {
         self.scalar == other.scalar
     }
 }
diff --git a/vortex-array/src/arrays/datetime/test.rs b/vortex-array/src/arrays/datetime/test.rs
index 2b1a681e7fb..511b8196a79 100644
--- a/vortex-array/src/arrays/datetime/test.rs
+++ b/vortex-array/src/arrays/datetime/test.rs
@@ -6,8 +6,8 @@ use vortex_buffer::buffer;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
+use crate::EqMode;
 use crate::IntoArray;
-use crate::Precision;
 #[expect(deprecated)]
 use crate::ToCanonical as _;
 use crate::arrays::PrimitiveArray;
@@ -201,7 +201,7 @@ fn test_validity_preservation(#[case] validity: Validity) {
     assert!(
         prim.validity()
             .vortex_expect("temporal validity should be derivable")
-            .array_eq(&validity, Precision::Ptr)
+            .array_eq(&validity, EqMode::Ptr)
     );
 }
 
diff --git a/vortex-array/src/arrays/decimal/vtable/mod.rs b/vortex-array/src/arrays/decimal/vtable/mod.rs
index dac24ecd95f..74e76ab4f51 100644
--- a/vortex-array/src/arrays/decimal/vtable/mod.rs
+++ b/vortex-array/src/arrays/decimal/vtable/mod.rs
@@ -34,7 +34,7 @@ use std::hash::Hash;
 
 use vortex_session::registry::CachedId;
 
-use crate::Precision;
+use crate::EqMode;
 use crate::array::ArrayId;
 use crate::arrays::decimal::array::SLOT_NAMES;
 use crate::arrays::decimal::compute::rules::RULES;
@@ -51,15 +51,15 @@ pub struct DecimalMetadata {
 }
 
 impl ArrayHash for DecimalData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
-        self.values.array_hash(state, precision);
+    fn array_hash<H: Hasher>(&self, state: &mut H, accuracy: EqMode) {
+        self.values.array_hash(state, accuracy);
         std::mem::discriminant(&self.values_type).hash(state);
     }
 }
 
 impl ArrayEq for DecimalData {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
-        self.values.array_eq(&other.values, precision) && self.values_type == other.values_type
+    fn array_eq(&self, other: &Self, accuracy: EqMode) -> bool {
+        self.values.array_eq(&other.values, accuracy) && self.values_type == other.values_type
     }
 }
 
diff --git a/vortex-array/src/arrays/dict/array.rs b/vortex-array/src/arrays/dict/array.rs
index 10108191744..59758924a19 100644
--- a/vortex-array/src/arrays/dict/array.rs
+++ b/vortex-array/src/arrays/dict/array.rs
@@ -135,7 +135,7 @@ pub trait DictArrayExt: TypedArrayRef<Dict> + DictArraySlotsExt {
             }
 
             let referenced_mask = self.compute_referenced_values_mask(true)?;
-            let all_referenced = referenced_mask.iter().all(|v| v);
+            let all_referenced = referenced_mask.true_count() == referenced_mask.len();
 
             vortex_ensure!(all_referenced, "value in dict not referenced");
         }
diff --git a/vortex-array/src/arrays/dict/compute/cast.rs b/vortex-array/src/arrays/dict/compute/cast.rs
index c269b214e19..490f1f31549 100644
--- a/vortex-array/src/arrays/dict/compute/cast.rs
+++ b/vortex-array/src/arrays/dict/compute/cast.rs
@@ -18,7 +18,7 @@ impl CastReduce for Dict {
     fn cast(array: ArrayView<'_, Dict>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
         // Can have un-reference null values making the cast of values fail without a possible mask.
         // TODO(joe): optimize this, could look at accessible values and fill_null not those?
-        if !dtype.is_nullable() && !array.values().validity()?.no_nulls() {
+        if !dtype.is_nullable() && !array.values().validity()?.definitely_no_nulls() {
             return Ok(None);
         }
         // Cast the dictionary values to the target type
diff --git a/vortex-array/src/arrays/dict/compute/fill_null.rs b/vortex-array/src/arrays/dict/compute/fill_null.rs
index 189d8240050..8f146d728a3 100644
--- a/vortex-array/src/arrays/dict/compute/fill_null.rs
+++ b/vortex-array/src/arrays/dict/compute/fill_null.rs
@@ -41,7 +41,7 @@ impl FillNullKernel for Dict {
 
         // We found the fill value already in the values at this given index.
         let Some(existing_fill_value_index) =
-            found_fill_values.to_bit_buffer().set_indices().next()
+            found_fill_values.bit_buffer_view().set_indices().next()
         else {
             // No fill values found, so we must canonicalize and fill_null.
             return Ok(Some(
diff --git a/vortex-array/src/arrays/dict/compute/rules.rs b/vortex-array/src/arrays/dict/compute/rules.rs
index f6fe816a6cc..024240e4030 100644
--- a/vortex-array/src/arrays/dict/compute/rules.rs
+++ b/vortex-array/src/arrays/dict/compute/rules.rs
@@ -5,8 +5,8 @@ use vortex_error::VortexResult;
 
 use crate::ArrayEq;
 use crate::ArrayRef;
+use crate::EqMode;
 use crate::IntoArray;
-use crate::Precision;
 use crate::array::ArrayView;
 use crate::array::VTable;
 use crate::arrays::Constant;
@@ -126,10 +126,9 @@ impl ArrayParentReduceRule<Dict> for DictionaryScalarFnValuesPushDownRule {
             }
         }
 
-        let new_values =
-            ScalarFnArray::try_new(parent.scalar_fn().clone(), new_children, values_len)?
-                .into_array()
-                .optimize()?;
+        let new_values = ScalarFnArray::try_new(parent.scalar_fn().clone(), new_children)?
+            .into_array()
+            .optimize()?;
 
         // We can only push down null-sensitive functions when we have all-valid codes.
         // In these cases, we cannot have the codes influence the nullability of the output DType.
@@ -175,11 +174,10 @@ impl ArrayParentReduceRule<Dict> for DictionaryScalarFnCodesPullUpRule {
         }
 
         // Now run the slightly more expensive check that all siblings have the same codes as us.
-        // We use the cheaper Precision::Ptr to avoid doing data comparisons.
         if !parent.iter_children().enumerate().all(|(idx, c)| {
             idx == child_idx
                 || c.as_opt::<Dict>()
-                    .is_some_and(|c| c.codes().array_eq(array.codes(), Precision::Value))
+                    .is_some_and(|c| c.codes().array_eq(array.codes(), EqMode::Value))
         }) {
             return Ok(None);
         }
@@ -193,13 +191,9 @@ impl ArrayParentReduceRule<Dict> for DictionaryScalarFnCodesPullUpRule {
             }
         }
 
-        let new_values = ScalarFnArray::try_new(
-            parent.scalar_fn().clone(),
-            new_children,
-            array.values().len(),
-        )?
-        .into_array()
-        .optimize()?;
+        let new_values = ScalarFnArray::try_new(parent.scalar_fn().clone(), new_children)?
+            .into_array()
+            .optimize()?;
 
         let new_dict =
             unsafe { DictArray::new_unchecked(array.codes().clone(), new_values) }.into_array();
diff --git a/vortex-array/src/arrays/dict/compute/slice.rs b/vortex-array/src/arrays/dict/compute/slice.rs
index 509fa7535d8..1552c9c9fea 100644
--- a/vortex-array/src/arrays/dict/compute/slice.rs
+++ b/vortex-array/src/arrays/dict/compute/slice.rs
@@ -3,6 +3,7 @@
 
 use std::ops::Range;
 
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
 use crate::ArrayRef;
@@ -12,35 +13,74 @@ use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
 use crate::arrays::Dict;
 use crate::arrays::DictArray;
+use crate::arrays::Primitive;
 use crate::arrays::dict::DictArraySlotsExt;
 use crate::arrays::slice::SliceReduce;
+use crate::expr::stats::Precision;
+use crate::expr::stats::Stat;
 use crate::scalar::Scalar;
+use crate::scalar::ScalarValue;
 
 impl SliceReduce for Dict {
     fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
-        let sliced_code = array.codes().slice(range)?;
+        if let Some(code) = array.codes().as_opt::<Constant>() {
+            return slice_constant_code(array, code.scalar(), range.len());
+        }
+
+        let sliced_code = if let Some(codes) = array.codes().as_typed::<Primitive>() {
+            let sliced_code = <Primitive as SliceReduce>::slice(codes, range)?
+                .vortex_expect("Primitive SliceReduce should always return Some");
+            // Because we specialize the primitive branch here, we have to make sure to handle the stat inheritance
+            inherit_slice_stats(array.codes(), &sliced_code);
+            sliced_code
+        } else {
+            array.codes().slice(range)?
+        };
+
         // TODO(joe): if the range is size 1 replace with a constant array
         if let Some(code) = sliced_code.as_opt::<Constant>() {
-            let code = code.scalar().as_primitive().as_::<usize>();
-            return if let Some(code) = code {
-                let values = array.values().slice(code..code + 1)?;
-                Ok(Some(
-                    DictArray::new(
-                        ConstantArray::new(0u8, sliced_code.len()).into_array(),
-                        values,
-                    )
-                    .into_array(),
-                ))
-            } else {
-                Ok(Some(
-                    ConstantArray::new(Scalar::null(array.dtype().clone()), sliced_code.len())
-                        .into_array(),
-                ))
-            };
+            return slice_constant_code(array, code.scalar(), sliced_code.len());
         }
         // SAFETY: slicing the codes preserves invariants.
+        let array =
+            unsafe { DictArray::new_unchecked(sliced_code, array.values().clone()).into_array() };
+
+        Ok(Some(array))
+    }
+}
+
+fn inherit_slice_stats(source: &ArrayRef, sliced: &ArrayRef) {
+    source.statistics().with_iter(|iter| {
+        sliced
+            .statistics()
+            .inherit(iter.filter(|(stat, value)| is_inheritable_true_slice_stat(*stat, value)));
+    });
+}
+
+fn is_inheritable_true_slice_stat(stat: Stat, value: &Precision<ScalarValue>) -> bool {
+    matches!(
+        stat,
+        Stat::IsConstant | Stat::IsSorted | Stat::IsStrictSorted
+    ) && value
+        .as_ref()
+        .as_exact()
+        .is_some_and(|value| matches!(value, ScalarValue::Bool(true)))
+}
+
+fn slice_constant_code(
+    array: ArrayView<'_, Dict>,
+    code: &Scalar,
+    len: usize,
+) -> VortexResult<Option<ArrayRef>> {
+    let code = code.as_primitive().as_::<usize>();
+    if let Some(code) = code {
+        let values = array.values().slice(code..code + 1)?;
+        Ok(Some(
+            DictArray::new(ConstantArray::new(0u8, len).into_array(), values).into_array(),
+        ))
+    } else {
         Ok(Some(
-            unsafe { DictArray::new_unchecked(sliced_code, array.values().clone()) }.into_array(),
+            ConstantArray::new(Scalar::null(array.dtype().clone()), len).into_array(),
         ))
     }
 }
diff --git a/vortex-array/src/arrays/dict/vtable/mod.rs b/vortex-array/src/arrays/dict/vtable/mod.rs
index 33db223de72..fa8515dd986 100644
--- a/vortex-array/src/arrays/dict/vtable/mod.rs
+++ b/vortex-array/src/arrays/dict/vtable/mod.rs
@@ -25,7 +25,7 @@ use crate::ArrayEq;
 use crate::ArrayHash;
 use crate::ArrayRef;
 use crate::Canonical;
-use crate::Precision;
+use crate::EqMode;
 use crate::array::Array;
 use crate::array::ArrayId;
 use crate::array::ArrayParts;
@@ -59,11 +59,11 @@ pub type DictArray = Array<Dict>;
 pub struct Dict;
 
 impl ArrayHash for DictData {
-    fn array_hash<H: Hasher>(&self, _state: &mut H, _precision: Precision) {}
+    fn array_hash<H: Hasher>(&self, _state: &mut H, _accuracy: EqMode) {}
 }
 
 impl ArrayEq for DictData {
-    fn array_eq(&self, _other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, _other: &Self, _accuracy: EqMode) -> bool {
         true
     }
 }
diff --git a/vortex-array/src/arrays/extension/compute/rules.rs b/vortex-array/src/arrays/extension/compute/rules.rs
index d7c8469d1dc..59a8c314517 100644
--- a/vortex-array/src/arrays/extension/compute/rules.rs
+++ b/vortex-array/src/arrays/extension/compute/rules.rs
@@ -85,6 +85,7 @@ mod tests {
     use vortex_mask::Mask;
     use vortex_session::VortexSession;
 
+    use crate::EmptyMetadata;
     use crate::IntoArray;
     #[expect(deprecated)]
     use crate::ToCanonical as _;
@@ -105,7 +106,6 @@ mod tests {
     use crate::dtype::extension::ExtDTypeRef;
     use crate::dtype::extension::ExtId;
     use crate::dtype::extension::ExtVTable;
-    use crate::extension::EmptyMetadata;
     use crate::optimizer::ArrayOptimizer;
     use crate::scalar::Scalar;
     use crate::scalar::ScalarValue;
diff --git a/vortex-array/src/arrays/filter/execute/mod.rs b/vortex-array/src/arrays/filter/execute/mod.rs
index e1db2471780..52b0373ac49 100644
--- a/vortex-array/src/arrays/filter/execute/mod.rs
+++ b/vortex-array/src/arrays/filter/execute/mod.rs
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-//! Execution logic for [`FilterArray`].
+//! Execution logic for [`super::FilterArray`].
 //!
 //! The main entrypoint is [`execute_filter`] which filters any [`Canonical`] array.
 
diff --git a/vortex-array/src/arrays/filter/execute/take/fixed_width.rs b/vortex-array/src/arrays/filter/execute/take/fixed_width.rs
index edafbeb9abd..3e508abd2c5 100644
--- a/vortex-array/src/arrays/filter/execute/take/fixed_width.rs
+++ b/vortex-array/src/arrays/filter/execute/take/fixed_width.rs
@@ -105,7 +105,7 @@ where
                 take_filtered_values::<T, P>(&child, filter, ranks, None)?
             };
 
-            let output_validity = if child_validity.no_nulls() {
+            let output_validity = if child_validity.definitely_no_nulls() {
                 ranks_validity.union_nullability(child_validity.nullability())
             } else {
                 let translated_indices =
@@ -120,7 +120,7 @@ where
         AllOr::Some(buf) => {
             let taken = take_filtered_values(child.as_slice(), filter, ranks, Some(buf))?;
 
-            let output_validity = if child_validity.no_nulls() {
+            let output_validity = if child_validity.definitely_no_nulls() {
                 ranks_validity.union_nullability(child_validity.nullability())
             } else {
                 let translated_indices =
diff --git a/vortex-array/src/arrays/filter/vtable.rs b/vortex-array/src/arrays/filter/vtable.rs
index 2361c541997..5be6bc6ac35 100644
--- a/vortex-array/src/arrays/filter/vtable.rs
+++ b/vortex-array/src/arrays/filter/vtable.rs
@@ -18,8 +18,8 @@ use crate::ArrayEq;
 use crate::ArrayHash;
 use crate::ArrayRef;
 use crate::Canonical;
+use crate::EqMode;
 use crate::IntoArray;
-use crate::Precision;
 use crate::array::Array;
 use crate::array::ArrayId;
 use crate::array::ArrayView;
@@ -51,14 +51,14 @@ pub type FilterArray = Array<Filter>;
 pub struct Filter;
 
 impl ArrayHash for FilterData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
-        self.mask.array_hash(state, precision);
+    fn array_hash<H: Hasher>(&self, state: &mut H, accuracy: EqMode) {
+        self.mask.array_hash(state, accuracy);
     }
 }
 
 impl ArrayEq for FilterData {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
-        self.mask.array_eq(&other.mask, precision)
+    fn array_eq(&self, other: &Self, accuracy: EqMode) -> bool {
+        self.mask.array_eq(&other.mask, accuracy)
     }
 }
 
diff --git a/vortex-array/src/arrays/fixed_size_list/array.rs b/vortex-array/src/arrays/fixed_size_list/array.rs
index cc82551ab82..f24001c4e78 100644
--- a/vortex-array/src/arrays/fixed_size_list/array.rs
+++ b/vortex-array/src/arrays/fixed_size_list/array.rs
@@ -12,6 +12,8 @@ use vortex_error::vortex_ensure;
 
 use crate::ArrayRef;
 use crate::ArraySlots;
+use crate::LEGACY_SESSION;
+use crate::VortexSessionExecute;
 use crate::array::Array;
 use crate::array::ArrayParts;
 use crate::array::TypedArrayRef;
@@ -236,11 +238,14 @@ pub trait FixedSizeListArrayExt: TypedArrayRef<FixedSizeList> {
             index,
             self.as_ref().len(),
         );
-        debug_assert!(
-            self.fixed_size_list_validity()
-                .is_valid(index)
-                .unwrap_or(false)
-        );
+        #[expect(clippy::debug_assert_with_mut_call)]
+        {
+            debug_assert!(
+                self.fixed_size_list_validity()
+                    .execute_is_valid(index, &mut LEGACY_SESSION.create_execution_ctx())
+                    .unwrap_or(false)
+            );
+        }
 
         let start = self.list_size() as usize * index;
         let end = self.list_size() as usize * (index + 1);
diff --git a/vortex-array/src/arrays/fixed_size_list/compute/take.rs b/vortex-array/src/arrays/fixed_size_list/compute/take.rs
index 8df3bae0b0c..193730f62c4 100644
--- a/vortex-array/src/arrays/fixed_size_list/compute/take.rs
+++ b/vortex-array/src/arrays/fixed_size_list/compute/take.rs
@@ -175,13 +175,11 @@ fn take_nullable_fsl<I: IntegerPType, E: IntegerPType>(
     let mut new_validity_builder = BitBufferMut::with_capacity(new_len);
 
     // Build the element indices while tracking which lists are null.
-    for (i, data_idx) in indices.iter().enumerate() {
+    for (data_idx, is_index_valid) in indices.iter().zip(indices_validity.iter()) {
         let data_idx = data_idx
             .to_usize()
             .unwrap_or_else(|| vortex_panic!("Failed to convert index to usize: {}", data_idx));
 
-        let is_index_valid = indices_validity.value(i);
-
         // The list is null if the index is null or the indexed element is null.
         if !is_index_valid || !array_validity.value(data_idx) {
             // Append placeholder zeros for null lists. These will be masked by the validity array.
diff --git a/vortex-array/src/arrays/fixed_size_list/tests/nested.rs b/vortex-array/src/arrays/fixed_size_list/tests/nested.rs
index efd6f630580..8fca62c0097 100644
--- a/vortex-array/src/arrays/fixed_size_list/tests/nested.rs
+++ b/vortex-array/src/arrays/fixed_size_list/tests/nested.rs
@@ -270,7 +270,6 @@ fn test_fsl_of_fsl_with_nulls() {
 
 #[test]
 fn test_deeply_nested_fsl() {
-    let _len = 2;
     let list_size = 2;
 
     // Create a 3-level nested FSL: FSL[FSL[FSL[i32]]].
diff --git a/vortex-array/src/arrays/fixed_size_list/vtable/mod.rs b/vortex-array/src/arrays/fixed_size_list/vtable/mod.rs
index ca38f3b777b..8d86e96a174 100644
--- a/vortex-array/src/arrays/fixed_size_list/vtable/mod.rs
+++ b/vortex-array/src/arrays/fixed_size_list/vtable/mod.rs
@@ -16,9 +16,9 @@ use vortex_session::registry::CachedId;
 use crate::ArrayEq;
 use crate::ArrayHash;
 use crate::ArrayRef;
+use crate::EqMode;
 use crate::ExecutionCtx;
 use crate::ExecutionResult;
-use crate::Precision;
 use crate::array::Array;
 use crate::array::ArrayId;
 use crate::array::ArrayView;
@@ -43,15 +43,13 @@ pub type FixedSizeListArray = Array<FixedSizeList>;
 pub struct FixedSizeList;
 
 impl ArrayHash for FixedSizeListData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
-        let _precision = precision;
+    fn array_hash<H: Hasher>(&self, state: &mut H, _accuracy: EqMode) {
         self.degenerate_len.hash(state);
     }
 }
 
 impl ArrayEq for FixedSizeListData {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
-        let _precision = precision;
+    fn array_eq(&self, other: &Self, _accuracy: EqMode) -> bool {
         self.degenerate_len == other.degenerate_len
     }
 }
diff --git a/vortex-array/src/arrays/interleave/execute/bool.rs b/vortex-array/src/arrays/interleave/execute/bool.rs
new file mode 100644
index 00000000000..755921abd59
--- /dev/null
+++ b/vortex-array/src/arrays/interleave/execute/bool.rs
@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Optimized [`Interleave`] implementation for boolean values.
+
+use num_traits::AsPrimitive;
+use vortex_buffer::BitBuffer;
+use vortex_buffer::BitBufferMut;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
+use vortex_mask::Mask;
+
+use super::super::Interleave;
+use super::super::InterleaveArrayExt;
+use crate::array::Array;
+use crate::arrays::Bool;
+use crate::arrays::BoolArray;
+use crate::arrays::Primitive;
+use crate::arrays::bool::BoolArrayExt;
+use crate::executor::ExecutionCtx;
+use crate::executor::ExecutionResult;
+use crate::match_each_unsigned_integer_ptype;
+use crate::require_child;
+use crate::validity::Validity;
+
+/// Gathers `N` boolean values under unsigned `array_indices` / `row_indices` selectors, scattering
+/// each selected bit (and its validity) into the output position it routes to.
+pub(super) fn execute(
+    array: Array<Interleave>,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ExecutionResult> {
+    let num_values = array.num_values();
+
+    // Drive every value and both selectors to canonical encodings so we can operate on raw bits.
+    let mut array = array;
+    for i in 0..num_values {
+        array = require_child!(array, array.value(i), i => Bool);
+    }
+    array = require_child!(array, array.array_indices(), num_values => Primitive);
+    array = require_child!(array, array.row_indices(), num_values + 1 => Primitive);
+
+    let dtype = array.as_ref().dtype().clone();
+    let len = array.as_ref().len();
+    let nullable = dtype.is_nullable();
+
+    // Materialize each value's bits, and its validity mask only when the output can be null.
+    let mut value_bits = Vec::with_capacity(num_values);
+    let mut value_validity = Vec::with_capacity(num_values);
+    for i in 0..num_values {
+        let value = array.value(i).as_::<Bool>();
+        let bits = value.to_bit_buffer();
+        let validity = nullable
+            .then(|| value.validity()?.execute_mask(bits.len(), ctx))
+            .transpose()?;
+        value_bits.push(bits);
+        value_validity.push(validity);
+    }
+
+    // Scatter directly from the typed selector buffers — no intermediate `usize` materialization.
+    let array_indices = array.array_indices().as_::<Primitive>();
+    let row_indices = array.row_indices().as_::<Primitive>();
+    let (values, validity) = match_each_unsigned_integer_ptype!(array_indices.ptype(), |A| {
+        match_each_unsigned_integer_ptype!(row_indices.ptype(), |R| {
+            gather(
+                len,
+                num_values,
+                &value_bits,
+                &value_validity,
+                array_indices.as_slice::<A>(),
+                row_indices.as_slice::<R>(),
+                nullable,
+            )?
+        })
+    });
+
+    let validity = match validity {
+        Some(bits) => Validity::from(bits.freeze()),
+        None => Validity::NonNullable,
+    };
+    Ok(ExecutionResult::done(BoolArray::try_new(
+        values.freeze(),
+        validity,
+    )?))
+}
+
+/// The scatter, monomorphized on the selector integer widths so each `(array_index, row_index)`
+/// pair is read straight from its packed buffer.
+///
+/// Output bits (and validity) are produced with [`BitBufferMut::collect_bool`], which packs 64
+/// results per word: every output bit is written branchlessly, avoiding a per-row `set`/`unset`
+/// (each of which would bounds-check and branch on the random bit value).
+#[allow(clippy::too_many_arguments)]
+fn gather<A: AsPrimitive<usize>, R: AsPrimitive<usize>>(
+    len: usize,
+    num_values: usize,
+    value_bits: &[BitBuffer],
+    value_validity: &[Option<Mask>],
+    branches: &[A],
+    rows: &[R],
+    nullable: bool,
+) -> VortexResult<(BitBufferMut, Option<BitBufferMut>)> {
+    // Validate the per-row bounds once up front (returning an error rather than panicking), so the
+    // word-packing passes below are tight branchless loops.
+    for i in 0..len {
+        let branch = branches[i].as_();
+        vortex_ensure!(branch < num_values, "interleave array index out of bounds");
+        vortex_ensure!(
+            rows[i].as_() < value_bits[branch].len(),
+            "interleave row index out of bounds"
+        );
+    }
+
+    let values =
+        BitBufferMut::collect_bool(len, |i| value_bits[branches[i].as_()].value(rows[i].as_()));
+
+    // A missing per-value mask means every row of that value is valid; only materialized when the
+    // output can be null.
+    let validity = nullable.then(|| {
+        BitBufferMut::collect_bool(len, |i| {
+            value_validity[branches[i].as_()]
+                .as_ref()
+                .is_none_or(|mask| mask.value(rows[i].as_()))
+        })
+    });
+
+    Ok((values, validity))
+}
diff --git a/vortex-array/src/arrays/interleave/execute/mod.rs b/vortex-array/src/arrays/interleave/execute/mod.rs
new file mode 100644
index 00000000000..05dcd161f62
--- /dev/null
+++ b/vortex-array/src/arrays/interleave/execute/mod.rs
@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Execution logic for [`Interleave`], dispatched on the value type.
+//!
+//! All values share a type (validated in [`Interleave::check`]), so the
+//! physical gather kernel is chosen from the first value. The selector types are an orthogonal
+//! concern handled within each kernel. Only boolean values are implemented today (see the [`bool`] module).
+//!
+//! [`Interleave::check`]: super::Interleave::check
+//! [`bool`]: module@crate::arrays::interleave::execute::bool
+
+mod bool;
+
+use vortex_error::VortexResult;
+use vortex_error::vortex_panic;
+
+use super::Interleave;
+use super::InterleaveArrayExt;
+use crate::array::Array;
+use crate::executor::ExecutionCtx;
+use crate::executor::ExecutionResult;
+
+/// Executes an [`InterleaveArray`](super::InterleaveArray) by dispatching on the value type.
+pub(super) fn execute(
+    array: Array<Interleave>,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ExecutionResult> {
+    if array.value(0).dtype().is_boolean() {
+        bool::execute(array, ctx)
+    } else {
+        let value_dtype = array.value(0).dtype().clone();
+        vortex_panic!(
+            "interleave execution is only implemented for boolean values; value dtype {} is not \
+             yet supported",
+            value_dtype
+        )
+    }
+}
diff --git a/vortex-array/src/arrays/interleave/mod.rs b/vortex-array/src/arrays/interleave/mod.rs
new file mode 100644
index 00000000000..dd5619559dc
--- /dev/null
+++ b/vortex-array/src/arrays/interleave/mod.rs
@@ -0,0 +1,619 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! The [`Interleave`] encoding: a lazy, random-access gather of `N` value arrays into one array,
+//! routed by a per-row `(array_index, row_index)` pair.
+//!
+//! # Specification
+//!
+//! An [`Interleave`] array has `N + 2` children: `N` *values* followed by an `array_indices`
+//! selector and a `row_indices` selector. The output has `array_indices.len()` rows, and output
+//! row `i` comes from `values[array_indices[i]][row_indices[i]]`.
+//!
+//! Unlike a `Merge`, which consumes each branch in order under a cursor, an [`Interleave`] is
+//! **random-access**: `row_indices` names an explicit position within the selected value array, so
+//! rows may be reordered, skipped, or repeated. A `Merge` is the special case where each value
+//! array is consumed front-to-back exactly once.
+//!
+//! Like a `Merge`, the value arrays are independent: each holds only its own rows, and the
+//! selectors stitch them back together. This distinguishes [`Interleave`] from an element-wise
+//! select such as `zip`, whose arguments are all full-length.
+//!
+//! ## Invariants
+//!
+//! - Both selectors are **non-nullable** and equal in length, which is the output length. They
+//!   record *where* each output row comes from, which is always a definite decision. Predicate
+//!   nullability must be resolved into definite indices by the caller *before* the interleave is
+//!   built.
+//! - `array_indices[i] < values.len()` and `row_indices[i] < values[array_indices[i]].len()` for
+//!   every `i`. These per-row bounds depend on the selector *values* and so are a runtime
+//!   precondition of the caller, checked in the execution kernels rather than at construction.
+//! - All values share a logical type up to nullability. The output type is that shared type with
+//!   the union of the values' nullabilities. This is orthogonal to the selectors: a row's *value*
+//!   may be null even though its `(array_index, row_index)` is definite.
+//! - The output length equals `array_indices.len()` (`== row_indices.len()`).
+//!
+//! ## Selector types
+//!
+//! `array_indices` encodes the value array per row as a non-nullable **unsigned integer**
+//! (`array_indices[i]` is the index into `values`). `row_indices` is likewise a non-nullable
+//! **unsigned integer** naming the position within the selected value array.
+
+mod execute;
+
+use std::fmt::Display;
+use std::fmt::Formatter;
+use std::hash::Hasher;
+
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_panic;
+use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
+
+use crate::ArrayEq;
+use crate::ArrayHash;
+use crate::ArrayRef;
+use crate::EqMode;
+use crate::ExecutionCtx;
+use crate::IntoArray;
+use crate::array::Array;
+use crate::array::ArrayId;
+use crate::array::ArrayParts;
+use crate::array::ArraySlots;
+use crate::array::ArrayView;
+use crate::array::OperationsVTable;
+use crate::array::TypedArrayRef;
+use crate::array::VTable;
+use crate::array::ValidityVTable;
+use crate::arrays::ConstantArray;
+use crate::buffer::BufferHandle;
+use crate::dtype::DType;
+use crate::dtype::Nullability;
+use crate::executor::ExecutionResult;
+use crate::scalar::Scalar;
+use crate::serde::ArrayChildren;
+use crate::validity::Validity;
+
+/// An [`Interleave`]-encoded Vortex array. See the [module docs](self) for the specification.
+pub type InterleaveArray = Array<Interleave>;
+
+/// The [`Interleave`] encoding. See the [module docs](self).
+#[derive(Clone, Debug)]
+pub struct Interleave;
+
+/// Per-array metadata for an [`InterleaveArray`].
+///
+/// The values and selectors live in the array's slots; only the value count is stored here so the
+/// selector slots can be located (`slots[num_values]` and `slots[num_values + 1]`).
+#[derive(Clone, Debug)]
+pub struct InterleaveData {
+    pub(crate) num_values: usize,
+}
+
+impl Display for InterleaveData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "num_values: {}", self.num_values)
+    }
+}
+
+impl ArrayHash for InterleaveData {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _accuracy: EqMode) {
+        state.write_usize(self.num_values);
+    }
+}
+
+impl ArrayEq for InterleaveData {
+    fn array_eq(&self, other: &Self, _accuracy: EqMode) -> bool {
+        self.num_values == other.num_values
+    }
+}
+
+/// Accessors for the values and selectors of an [`InterleaveArray`].
+pub trait InterleaveArrayExt: TypedArrayRef<Interleave> {
+    /// The number of value arrays (two fewer than the number of children).
+    fn num_values(&self) -> usize {
+        self.num_values
+    }
+
+    /// The `idx`-th value array (holding the rows that `array_indices` routes to it).
+    fn value(&self, idx: usize) -> &ArrayRef {
+        self.as_ref().slots()[idx]
+            .as_ref()
+            .vortex_expect("validated interleave value slot")
+    }
+
+    /// The selector routing each output row to a value array.
+    fn array_indices(&self) -> &ArrayRef {
+        self.as_ref().slots()[self.num_values]
+            .as_ref()
+            .vortex_expect("validated interleave array_indices slot")
+    }
+
+    /// The selector naming each output row's position within its value array.
+    fn row_indices(&self) -> &ArrayRef {
+        self.as_ref().slots()[self.num_values + 1]
+            .as_ref()
+            .vortex_expect("validated interleave row_indices slot")
+    }
+}
+impl<T: TypedArrayRef<Interleave>> InterleaveArrayExt for T {}
+
+impl Interleave {
+    /// The single source of truth for [`InterleaveArray`] invariants.
+    ///
+    /// Validates `values`, `array_indices`, and `row_indices` against the [specification](self) and
+    /// returns the output [`DType`] (the shared value type with the union of value nullabilities).
+    /// Both the public constructor and the [`VTable::validate`] hook funnel through here.
+    fn check(
+        values: &[ArrayRef],
+        array_indices: &ArrayRef,
+        row_indices: &ArrayRef,
+    ) -> VortexResult<DType> {
+        vortex_ensure!(
+            values.len() >= 2,
+            "interleave requires at least 2 values, got {}",
+            values.len()
+        );
+
+        // Both selectors are non-nullable unsigned integers: `array_indices` indexes the values and
+        // `row_indices` names a position within the selected value.
+        for (name, selector) in [
+            ("array_indices", array_indices),
+            ("row_indices", row_indices),
+        ] {
+            match selector.dtype() {
+                DType::Primitive(ptype, nullability) if ptype.is_unsigned_int() => {
+                    vortex_ensure!(
+                        !nullability.is_nullable(),
+                        "interleave {name} must be non-nullable, got {}",
+                        selector.dtype()
+                    );
+                }
+                other => vortex_bail!(
+                    "interleave {name} must be a non-nullable unsigned integer, got {other}"
+                ),
+            }
+        }
+
+        vortex_ensure!(
+            array_indices.len() == row_indices.len(),
+            "interleave selectors must have equal length, got array_indices {} and row_indices {}",
+            array_indices.len(),
+            row_indices.len()
+        );
+
+        let base_dtype = values[0].dtype();
+        let mut nullability = Nullability::NonNullable;
+        for value in values {
+            vortex_ensure!(
+                value.dtype().eq_ignore_nullability(base_dtype),
+                "interleave values must share a dtype up to nullability: {} vs {}",
+                base_dtype,
+                value.dtype()
+            );
+            nullability |= value.dtype().nullability();
+        }
+
+        Ok(base_dtype.with_nullability(nullability))
+    }
+}
+
+impl Array<Interleave> {
+    /// Constructs a new [`InterleaveArray`] from `values` and the `array_indices` / `row_indices`
+    /// selectors.
+    ///
+    /// See the [module docs](self) for the full specification and invariants. The selectors must be
+    /// non-nullable: they record a definite `(array_index, row_index)` per row, so null-predicate
+    /// handling is the caller's responsibility, resolved before the interleave is constructed. The
+    /// per-row bounds on the selector values are a runtime precondition checked during execution.
+    pub fn try_new(
+        values: Vec<ArrayRef>,
+        array_indices: ArrayRef,
+        row_indices: ArrayRef,
+    ) -> VortexResult<Self> {
+        let dtype = Interleave::check(&values, &array_indices, &row_indices)?;
+        let len = array_indices.len();
+        let num_values = values.len();
+
+        let mut slots: ArraySlots = values.into_iter().map(Some).collect();
+        slots.push(Some(array_indices));
+        slots.push(Some(row_indices));
+
+        Ok(unsafe {
+            Array::from_parts_unchecked(
+                ArrayParts::new(Interleave, dtype, len, InterleaveData { num_values })
+                    .with_slots(slots),
+            )
+        })
+    }
+}
+
+impl VTable for Interleave {
+    type TypedArrayData = InterleaveData;
+    type OperationsVTable = Self;
+    type ValidityVTable = Self;
+
+    fn id(&self) -> ArrayId {
+        static ID: CachedId = CachedId::new("vortex.interleave");
+        *ID
+    }
+
+    fn validate(
+        &self,
+        data: &Self::TypedArrayData,
+        dtype: &DType,
+        len: usize,
+        slots: &[Option<ArrayRef>],
+    ) -> VortexResult<()> {
+        vortex_ensure!(
+            slots.len() == data.num_values + 2,
+            "InterleaveArray expected {} slots (values + array_indices + row_indices), got {}",
+            data.num_values + 2,
+            slots.len()
+        );
+        vortex_ensure!(
+            slots.iter().all(|s| s.is_some()),
+            "InterleaveArray slots must all be present"
+        );
+
+        let values: Vec<ArrayRef> = slots[..data.num_values]
+            .iter()
+            .map(|s| s.clone().vortex_expect("validated value slot"))
+            .collect();
+        let array_indices = slots[data.num_values]
+            .clone()
+            .vortex_expect("validated array_indices slot");
+        let row_indices = slots[data.num_values + 1]
+            .clone()
+            .vortex_expect("validated row_indices slot");
+
+        // All semantic invariants live in `check`; here we only confirm the array's cached `dtype`
+        // and `len` agree with what the children imply.
+        let expected_dtype = Interleave::check(&values, &array_indices, &row_indices)?;
+        vortex_ensure!(
+            dtype == &expected_dtype,
+            "InterleaveArray dtype {} does not match the dtype implied by its children {}",
+            dtype,
+            expected_dtype
+        );
+        vortex_ensure!(
+            len == array_indices.len(),
+            "InterleaveArray length {} does not match array_indices length {}",
+            len,
+            array_indices.len()
+        );
+        Ok(())
+    }
+
+    fn nbuffers(_array: ArrayView<'_, Self>) -> usize {
+        0
+    }
+
+    fn buffer(_array: ArrayView<'_, Self>, _idx: usize) -> BufferHandle {
+        vortex_panic!("InterleaveArray has no buffers")
+    }
+
+    fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
+        None
+    }
+
+    fn slot_name(array: ArrayView<'_, Self>, idx: usize) -> String {
+        if idx == array.num_values() {
+            "array_indices".to_string()
+        } else if idx == array.num_values() + 1 {
+            "row_indices".to_string()
+        } else {
+            format!("value_{idx}")
+        }
+    }
+
+    fn serialize(
+        _array: ArrayView<'_, Self>,
+        _session: &VortexSession,
+    ) -> VortexResult<Option<Vec<u8>>> {
+        vortex_bail!("Interleave array is not serializable")
+    }
+
+    fn deserialize(
+        &self,
+        _dtype: &DType,
+        _len: usize,
+        _metadata: &[u8],
+        _buffers: &[BufferHandle],
+        _children: &dyn ArrayChildren,
+        _session: &VortexSession,
+    ) -> VortexResult<ArrayParts<Self>> {
+        vortex_bail!("Interleave array is not serializable")
+    }
+
+    fn execute(array: Array<Self>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        execute::execute(array, ctx)
+    }
+}
+
+impl OperationsVTable<Interleave> for Interleave {
+    fn scalar_at(
+        array: ArrayView<'_, Interleave>,
+        index: usize,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Scalar> {
+        // Random-access gather: read the routing pair for `index` directly, then pull that row from
+        // the selected value array. No cursor walk is required.
+        let branch_idx = array
+            .array_indices()
+            .execute_scalar(index, ctx)?
+            .as_primitive()
+            .as_::<usize>()
+            .vortex_expect("interleave array_indices is non-nullable");
+        let row = array
+            .row_indices()
+            .execute_scalar(index, ctx)?
+            .as_primitive()
+            .as_::<usize>()
+            .vortex_expect("interleave row_indices is non-nullable");
+
+        let scalar = array.value(branch_idx).execute_scalar(row, ctx)?;
+        // The value may be non-nullable while the interleaved output is nullable; align the dtype.
+        Ok(if array.as_ref().dtype().is_nullable() {
+            scalar.into_nullable()
+        } else {
+            scalar
+        })
+    }
+}
+
+impl ValidityVTable<Interleave> for Interleave {
+    fn validity(array: ArrayView<'_, Interleave>) -> VortexResult<Validity> {
+        if !array.as_ref().dtype().is_nullable() {
+            return Ok(Validity::NonNullable);
+        }
+        // The output validity is itself an interleave — by the same selectors — of the values'
+        // validities, expressed as non-nullable boolean arrays. This bottoms out immediately
+        // because the inner interleave is non-nullable.
+        let mut value_validities: Vec<ArrayRef> = Vec::with_capacity(array.num_values());
+        for i in 0..array.num_values() {
+            value_validities.push(value_validity_array(array.value(i))?);
+        }
+        let interleaved = InterleaveArray::try_new(
+            value_validities,
+            array.array_indices().clone(),
+            array.row_indices().clone(),
+        )?;
+        Ok(Validity::Array(interleaved.into_array()))
+    }
+}
+
+/// Materializes a value's validity as a non-nullable boolean array of the value's length, where
+/// `true` marks a valid (non-null) row.
+fn value_validity_array(value: &ArrayRef) -> VortexResult<ArrayRef> {
+    Ok(match value.validity()? {
+        Validity::NonNullable | Validity::AllValid => {
+            ConstantArray::new(true, value.len()).into_array()
+        }
+        Validity::AllInvalid => ConstantArray::new(false, value.len()).into_array(),
+        Validity::Array(array) => array,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_error::VortexResult;
+
+    use super::*;
+    use crate::Canonical;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::arrays::BoolArray;
+    use crate::arrays::PrimitiveArray;
+    use crate::assert_arrays_eq;
+
+    /// Reference (oracle) implementation of the interleave spec, used only to validate the optimized
+    /// [execute](super::execute) path. It is intentionally simple and slow: it pulls each output
+    /// element one [`Scalar`] at a time via [`ArrayRef::execute_scalar`] and never touches raw bits.
+    ///
+    /// This is deliberately *not* wired into the array execution path — it exists purely as a
+    /// trustworthy comparison point in tests.
+    fn interleave_reference(
+        values: &[ArrayRef],
+        array_indices: &ArrayRef,
+        row_indices: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let len = array_indices.len();
+        let nullable = values.iter().any(|v| v.dtype().is_nullable());
+        let mut out: Vec<Option<bool>> = Vec::with_capacity(len);
+
+        for i in 0..len {
+            let j = array_indices
+                .execute_scalar(i, ctx)?
+                .as_primitive()
+                .as_::<usize>()
+                .vortex_expect("array_indices is non-nullable");
+            let row = row_indices
+                .execute_scalar(i, ctx)?
+                .as_primitive()
+                .as_::<usize>()
+                .vortex_expect("row_indices is non-nullable");
+            out.push(values[j].execute_scalar(row, ctx)?.as_bool().value());
+        }
+
+        Ok(if nullable {
+            BoolArray::from_iter(out).into_array()
+        } else {
+            BoolArray::from_iter(
+                out.into_iter()
+                    .map(|v| v.vortex_expect("non-nullable value produced a null")),
+            )
+            .into_array()
+        })
+    }
+
+    /// Builds the compact value arrays and the unsigned `(array_indices, row_indices)` selectors for
+    /// a gather described by per-output `(array_index, row_index)` pairs over `branches`.
+    fn build(
+        branches: &[&[Option<bool>]],
+        indices: &[(usize, usize)],
+    ) -> (Vec<ArrayRef>, ArrayRef, ArrayRef) {
+        let nullable = branches.iter().flat_map(|b| b.iter()).any(Option::is_none);
+        let to_value = |vals: &[Option<bool>]| -> ArrayRef {
+            if nullable {
+                BoolArray::from_iter(vals.iter().copied()).into_array()
+            } else {
+                BoolArray::from_iter(
+                    vals.iter()
+                        .map(|v| v.vortex_expect("non-nullable value produced a null")),
+                )
+                .into_array()
+            }
+        };
+
+        let values = branches.iter().map(|b| to_value(b)).collect();
+        let array_indices = PrimitiveArray::from_iter(
+            indices
+                .iter()
+                .map(|&(a, _)| u32::try_from(a).vortex_expect("array index fits in u32")),
+        )
+        .into_array();
+        let row_indices = PrimitiveArray::from_iter(
+            indices
+                .iter()
+                .map(|&(_, r)| u32::try_from(r).vortex_expect("row index fits in u32")),
+        )
+        .into_array();
+        (values, array_indices, row_indices)
+    }
+
+    /// Asserts that the optimized execute path and the reference implementation agree, exercising
+    /// `InterleaveArray` construction, `execute`, `scalar_at`, and `validity` (via
+    /// `assert_arrays_eq`).
+    fn check(branches: &[&[Option<bool>]], indices: &[(usize, usize)]) -> VortexResult<()> {
+        let (values, array_indices, row_indices) = build(branches, indices);
+
+        let interleaved =
+            InterleaveArray::try_new(values.clone(), array_indices.clone(), row_indices.clone())?
+                .into_array();
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let reference = interleave_reference(&values, &array_indices, &row_indices, &mut ctx)?;
+
+        assert_arrays_eq!(interleaved, reference);
+        Ok(())
+    }
+
+    #[test]
+    fn interleave_reorders_and_repeats() -> VortexResult<()> {
+        // Random access: rows are pulled out of order and branch 0 row 0 is repeated.
+        check(
+            &[&[Some(true), Some(false)], &[Some(false), Some(true)]],
+            &[(0, 1), (1, 0), (0, 0), (1, 1), (0, 0)],
+        )
+    }
+
+    #[test]
+    fn interleave_skips_rows() -> VortexResult<()> {
+        // Branch 0 row 1 and branch 1 row 0 are never gathered.
+        check(
+            &[
+                &[Some(true), Some(false), Some(true)],
+                &[Some(false), Some(true)],
+            ],
+            &[(0, 0), (1, 1), (0, 2)],
+        )
+    }
+
+    #[test]
+    fn interleave_three_values() -> VortexResult<()> {
+        // An unsigned `array_indices` routes among three values with full random access.
+        check(
+            &[
+                &[Some(true), Some(false)],
+                &[Some(false)],
+                &[Some(true), Some(true), Some(false)],
+            ],
+            &[(2, 1), (0, 0), (1, 0), (2, 2), (0, 1), (2, 0)],
+        )
+    }
+
+    #[test]
+    fn interleave_only_one_branch() -> VortexResult<()> {
+        check(
+            &[&[Some(true), Some(false), Some(true)], &[Some(false)]],
+            &[(0, 2), (0, 0), (0, 1)],
+        )
+    }
+
+    #[test]
+    fn interleave_nullable_with_nulls_in_values() -> VortexResult<()> {
+        check(
+            &[&[None, Some(true), None], &[Some(false), None]],
+            &[(1, 1), (0, 0), (1, 0), (0, 2), (0, 1)],
+        )
+    }
+
+    #[test]
+    fn interleave_empty() -> VortexResult<()> {
+        check(&[&[Some(true)], &[Some(false)]], &[])
+    }
+
+    #[test]
+    fn rejects_boolean_array_indices() {
+        let value = BoolArray::from_iter([true, false]).into_array();
+        let array_indices = BoolArray::from_iter([true, false]).into_array();
+        let row_indices = PrimitiveArray::from_iter([0u32, 1]).into_array();
+        let err = InterleaveArray::try_new(vec![value.clone(), value], array_indices, row_indices)
+            .err()
+            .vortex_expect("expected interleave to reject a boolean array_indices");
+        assert!(err.to_string().contains("unsigned integer"), "{err}");
+    }
+
+    #[test]
+    fn rejects_signed_integer_array_indices() {
+        let value = BoolArray::from_iter([true]).into_array();
+        let array_indices = PrimitiveArray::from_iter([0i32, 1]).into_array();
+        let row_indices = PrimitiveArray::from_iter([0u32, 0]).into_array();
+        let err = InterleaveArray::try_new(vec![value.clone(), value], array_indices, row_indices)
+            .err()
+            .vortex_expect("expected interleave to reject a signed integer array_indices");
+        assert!(err.to_string().contains("unsigned integer"), "{err}");
+    }
+
+    #[test]
+    fn rejects_nullable_row_indices() {
+        let value = BoolArray::from_iter([true, false]).into_array();
+        let array_indices = PrimitiveArray::from_iter([0u32, 1]).into_array();
+        let row_indices = PrimitiveArray::from_option_iter([Some(0u32), Some(1)]).into_array();
+        let err = InterleaveArray::try_new(vec![value.clone(), value], array_indices, row_indices)
+            .err()
+            .vortex_expect("expected interleave to reject nullable row_indices");
+        assert!(err.to_string().contains("non-nullable"), "{err}");
+    }
+
+    #[test]
+    fn rejects_mismatched_selector_lengths() {
+        let value = BoolArray::from_iter([true, false]).into_array();
+        let array_indices = PrimitiveArray::from_iter([0u32, 1]).into_array();
+        let row_indices = PrimitiveArray::from_iter([0u32]).into_array();
+        let err = InterleaveArray::try_new(vec![value.clone(), value], array_indices, row_indices)
+            .err()
+            .vortex_expect("expected interleave to reject mismatched selector lengths");
+        assert!(err.to_string().contains("equal length"), "{err}");
+    }
+
+    #[test]
+    #[should_panic(expected = "only implemented for boolean values")]
+    fn non_boolean_value_execution_panics() {
+        // Execution dispatches on the value type: primitive values have no kernel yet.
+        let v0 = PrimitiveArray::from_iter([1u32]).into_array();
+        let v1 = PrimitiveArray::from_iter([2u32]).into_array();
+        let array_indices = PrimitiveArray::from_iter([0u32, 1]).into_array();
+        let row_indices = PrimitiveArray::from_iter([0u32, 0]).into_array();
+        let interleaved = InterleaveArray::try_new(vec![v0, v1], array_indices, row_indices)
+            .vortex_expect("primitive values should construct")
+            .into_array();
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        interleaved.execute::<Canonical>(&mut ctx).ok();
+    }
+}
diff --git a/vortex-array/src/arrays/list/array.rs b/vortex-array/src/arrays/list/array.rs
index 3e1c43ea3e9..7788511aa25 100644
--- a/vortex-array/src/arrays/list/array.rs
+++ b/vortex-array/src/arrays/list/array.rs
@@ -15,6 +15,8 @@ use vortex_error::vortex_panic;
 
 use crate::ArrayRef;
 use crate::ArraySlots;
+use crate::Canonical;
+use crate::ExecutionCtx;
 use crate::IntoArray;
 use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
@@ -329,21 +331,24 @@ pub trait ListArrayExt: TypedArrayRef<List> {
         self.elements().dtype()
     }
 
-    fn reset_offsets(&self, recurse: bool) -> VortexResult<Array<List>> {
+    fn reset_offsets(&self, recurse: bool, ctx: &mut ExecutionCtx) -> VortexResult<Array<List>> {
         let mut elements = self.sliced_elements()?;
         if recurse && elements.is_canonical() {
-            #[expect(deprecated)]
-            let compacted = elements.to_canonical()?.compact()?.into_array();
+            let compacted = elements
+                .clone()
+                .execute::<Canonical>(ctx)?
+                .compact(ctx)?
+                .into_array();
             elements = compacted;
         } else if recurse && let Some(child_list_array) = elements.as_opt::<List>() {
             elements = child_list_array
                 .into_owned()
-                .reset_offsets(recurse)?
+                .reset_offsets(recurse, ctx)?
                 .into_array();
         }
 
         let offsets = self.offsets();
-        let first_offset = offsets.execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let first_offset = offsets.execute_scalar(0, ctx)?;
         let adjusted_offsets = offsets.clone().binary(
             ConstantArray::new(first_offset, offsets.len()).into_array(),
             Operator::Sub,
diff --git a/vortex-array/src/arrays/list/compute/take.rs b/vortex-array/src/arrays/list/compute/take.rs
index 43117b1b834..f96cac5cf32 100644
--- a/vortex-array/src/arrays/list/compute/take.rs
+++ b/vortex-array/src/arrays/list/compute/take.rs
@@ -164,8 +164,8 @@ fn _take_nullable<I: IntegerPType, O: IntegerPType, OutputOffsetType: IntegerPTy
     let mut current_offset = OutputOffsetType::zero();
     new_offsets.append_zero();
 
-    for (idx, data_idx) in indices.iter().enumerate() {
-        if !indices_validity.value(idx) {
+    for (data_idx, index_valid) in indices.iter().zip(indices_validity.iter()) {
+        if !index_valid {
             new_offsets.append_value(current_offset);
             continue;
         }
diff --git a/vortex-array/src/arrays/list/tests.rs b/vortex-array/src/arrays/list/tests.rs
index f27e0a9f305..2ed260a5f55 100644
--- a/vortex-array/src/arrays/list/tests.rs
+++ b/vortex-array/src/arrays/list/tests.rs
@@ -2,17 +2,18 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::sync::Arc;
+use std::sync::LazyLock;
 
 use vortex_buffer::BitBuffer;
 use vortex_buffer::buffer;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
+use vortex_session::VortexSession;
 
 use super::*;
 use crate::Canonical;
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
 use crate::arrays::FilterArray;
 use crate::arrays::List;
@@ -24,8 +25,13 @@ use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::dtype::PType::I32;
 use crate::scalar::Scalar;
+use crate::session::ArraySession;
 use crate::validity::Validity;
 
+/// A shared session for `List` tests, used to create execution contexts.
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 #[test]
 fn test_empty_list_array() {
     let elements = PrimitiveArray::empty::<u32>(Nullability::NonNullable);
@@ -39,6 +45,7 @@ fn test_empty_list_array() {
 
 #[test]
 fn test_simple_list_array() {
+    let mut ctx = SESSION.create_execution_ctx();
     let elements = buffer![1i32, 2, 3, 4, 5].into_array();
     let offsets = buffer![0, 2, 4, 5].into_array();
     let validity = Validity::AllValid;
@@ -51,8 +58,7 @@ fn test_simple_list_array() {
             vec![1.into(), 2.into()],
             Nullability::Nullable
         ),
-        list.execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
+        list.execute_scalar(0, &mut ctx).unwrap()
     );
     assert_eq!(
         Scalar::list(
@@ -60,18 +66,17 @@ fn test_simple_list_array() {
             vec![3.into(), 4.into()],
             Nullability::Nullable
         ),
-        list.execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
+        list.execute_scalar(1, &mut ctx).unwrap()
     );
     assert_eq!(
         Scalar::list(Arc::new(I32.into()), vec![5.into()], Nullability::Nullable),
-        list.execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
+        list.execute_scalar(2, &mut ctx).unwrap()
     );
 }
 
 #[test]
 fn test_simple_list_array_from_iter() {
+    let mut ctx = SESSION.create_execution_ctx();
     let elements = buffer![1i32, 2, 3].into_array();
     let offsets = buffer![0, 2, 3].into_array();
     let validity = Validity::NonNullable;
@@ -84,18 +89,12 @@ fn test_simple_list_array_from_iter() {
 
     assert_eq!(list.len(), list_from_iter.len());
     assert_eq!(
-        list.execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap(),
-        list_from_iter
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
+        list.execute_scalar(0, &mut ctx).unwrap(),
+        list_from_iter.execute_scalar(0, &mut ctx).unwrap()
     );
     assert_eq!(
-        list.execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap(),
-        list_from_iter
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
+        list.execute_scalar(1, &mut ctx).unwrap(),
+        list_from_iter.execute_scalar(1, &mut ctx).unwrap()
     );
 }
 
@@ -208,6 +207,7 @@ fn test_list_filter_empty_lists() {
 
 #[test]
 fn test_list_filter_with_nulls() {
+    let mut ctx = SESSION.create_execution_ctx();
     // Test filtering lists with null validity.
     let elements = buffer![0..15].into_array();
     let offsets = buffer![0, 3, 7, 10, 12, 15].into_array();
@@ -227,30 +227,10 @@ fn test_list_filter_with_nulls() {
     assert_eq!(filtered.len(), 4);
 
     // Check validity of filtered array using scalar_at (works on any array).
-    assert!(
-        filtered
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
-            .is_valid()
-    );
-    assert!(
-        !filtered
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
-            .is_valid()
-    ); // Was null.
-    assert!(
-        !filtered
-            .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
-            .is_valid()
-    ); // Was null.
-    assert!(
-        filtered
-            .execute_scalar(3, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
-            .is_valid()
-    );
+    assert!(filtered.execute_scalar(0, &mut ctx).unwrap().is_valid());
+    assert!(!filtered.execute_scalar(1, &mut ctx).unwrap().is_valid()); // Was null.
+    assert!(!filtered.execute_scalar(2, &mut ctx).unwrap().is_valid()); // Was null.
+    assert!(filtered.execute_scalar(3, &mut ctx).unwrap().is_valid());
 }
 
 #[test]
@@ -655,7 +635,7 @@ fn test_list_of_lists() {
 
     // Test scalar conversion.
     let scalar = list_of_lists
-        .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(0, &mut SESSION.create_execution_ctx())
         .unwrap();
     assert!(matches!(scalar.dtype(), DType::List(_, _)));
     let list_scalar = scalar.as_list();
@@ -679,6 +659,7 @@ fn test_list_of_lists() {
 
 #[test]
 fn test_list_of_lists_nullable_outer() {
+    let mut ctx = SESSION.create_execution_ctx();
     // Create list of lists with nullable outer, non-nullable inner.
     // Structure: [[[1, 2], [3]], null, [[4, 5, 6]], [[7]]]
     let data = vec![
@@ -701,15 +682,11 @@ fn test_list_of_lists_nullable_outer() {
     ));
 
     // First element should be [[1, 2], [3]].
-    let first = list_of_lists
-        .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
-        .unwrap();
+    let first = list_of_lists.execute_scalar(0, &mut ctx).unwrap();
     assert!(!first.is_null());
 
     // Second element should be null.
-    let second = list_of_lists
-        .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
-        .unwrap();
+    let second = list_of_lists.execute_scalar(1, &mut ctx).unwrap();
     assert!(second.is_null());
 
     // Third element should be [[4, 5, 6]].
@@ -764,13 +741,14 @@ fn test_list_of_lists_nullable_inner() {
     // Check that second inner list is null.
     let second_inner = first_list
         .array()
-        .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(1, &mut SESSION.create_execution_ctx())
         .unwrap();
     assert!(second_inner.is_null());
 }
 
 #[test]
 fn test_list_of_lists_both_nullable() {
+    let mut ctx = SESSION.create_execution_ctx();
     // Create list of lists with both nullable.
     // Structure: [[[1, 2], null], null, [[3]], [null]]
     let data = vec![
@@ -793,9 +771,7 @@ fn test_list_of_lists_both_nullable() {
     ));
 
     // First outer list should have 2 elements, second is null inner list.
-    let first_outer = list_of_lists
-        .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
-        .unwrap();
+    let first_outer = list_of_lists.execute_scalar(0, &mut ctx).unwrap();
     assert!(!first_outer.is_null());
     let first_outer_array = list_of_lists.list_elements_at(0).unwrap();
     let first_list = first_outer_array.as_::<List>();
@@ -806,16 +782,11 @@ fn test_list_of_lists_both_nullable() {
     assert_eq!(first_inner.len(), 2);
 
     // Second inner list should be null.
-    let second_inner = first_list
-        .array()
-        .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
-        .unwrap();
+    let second_inner = first_list.array().execute_scalar(1, &mut ctx).unwrap();
     assert!(second_inner.is_null());
 
     // Second outer list should be null.
-    let second_outer = list_of_lists
-        .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
-        .unwrap();
+    let second_outer = list_of_lists.execute_scalar(1, &mut ctx).unwrap();
     assert!(second_outer.is_null());
 
     // Third outer list should have [3].
@@ -829,10 +800,7 @@ fn test_list_of_lists_both_nullable() {
     let fourth_outer = list_of_lists.list_elements_at(3).unwrap();
     let fourth_list = fourth_outer.as_::<List>();
     assert_eq!(fourth_list.len(), 1);
-    let inner = fourth_list
-        .array()
-        .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
-        .unwrap();
+    let inner = fourth_list.array().execute_scalar(0, &mut ctx).unwrap();
     assert!(inner.is_null());
 }
 
@@ -925,6 +893,7 @@ fn test_offsets_constant() {
 
 #[test]
 fn test_recursive_compact_list_of_lists() {
+    let mut ctx = SESSION.create_execution_ctx();
     // Create a nested list structure: [[[1,2,3], [4,5]], [[6,7,8,9]], [[10], [11,12]]]
     let nested_data = vec![
         Some(vec![
@@ -941,9 +910,9 @@ fn test_recursive_compact_list_of_lists() {
     let sliced_list = sliced.as_::<List>();
 
     // Test non-recursive compaction: only resets outer list offsets
-    let non_recursive = sliced_list.reset_offsets(false).unwrap();
+    let non_recursive = sliced_list.reset_offsets(false, &mut ctx).unwrap();
     // Test recursive compaction: resets offsets and compacts inner canonical arrays
-    let recursive = sliced_list.reset_offsets(true).unwrap();
+    let recursive = sliced_list.reset_offsets(true, &mut ctx).unwrap();
 
     assert_eq!(non_recursive.len(), 2);
     assert_eq!(recursive.len(), 2);
@@ -964,12 +933,8 @@ fn test_recursive_compact_list_of_lists() {
     let non_recursive_array = non_recursive.into_array();
     let recursive_array = recursive.into_array();
     assert_eq!(
-        non_recursive_array
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap(),
-        recursive_array
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
+        non_recursive_array.execute_scalar(0, &mut ctx).unwrap(),
+        recursive_array.execute_scalar(0, &mut ctx).unwrap()
     );
 }
 
@@ -985,7 +950,7 @@ fn test_filter_sliced_list_array() -> VortexResult<()> {
 
     let mask = Mask::from(BitBuffer::from(vec![true, false, true]));
     let filter_array = FilterArray::new(list, mask).into_array();
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = SESSION.create_execution_ctx();
     let result = filter_array.execute::<Canonical>(&mut ctx)?;
 
     assert_eq!(result.len(), 2);
diff --git a/vortex-array/src/arrays/list/vtable/mod.rs b/vortex-array/src/arrays/list/vtable/mod.rs
index 1b404e9edbc..d93c4673302 100644
--- a/vortex-array/src/arrays/list/vtable/mod.rs
+++ b/vortex-array/src/arrays/list/vtable/mod.rs
@@ -16,10 +16,10 @@ use vortex_session::registry::CachedId;
 use crate::ArrayEq;
 use crate::ArrayHash;
 use crate::ArrayRef;
+use crate::EqMode;
 use crate::ExecutionCtx;
 use crate::ExecutionResult;
 use crate::IntoArray;
-use crate::Precision;
 use crate::array::Array;
 use crate::array::ArrayId;
 use crate::array::ArrayParts;
@@ -54,11 +54,11 @@ pub struct ListMetadata {
 }
 
 impl ArrayHash for ListData {
-    fn array_hash<H: Hasher>(&self, _state: &mut H, _precision: Precision) {}
+    fn array_hash<H: Hasher>(&self, _state: &mut H, _accuracy: EqMode) {}
 }
 
 impl ArrayEq for ListData {
-    fn array_eq(&self, _other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, _other: &Self, _accuracy: EqMode) -> bool {
         true
     }
 }
diff --git a/vortex-array/src/arrays/listview/compute/mod.rs b/vortex-array/src/arrays/listview/compute/mod.rs
index 9a43503c4b5..87587495f7a 100644
--- a/vortex-array/src/arrays/listview/compute/mod.rs
+++ b/vortex-array/src/arrays/listview/compute/mod.rs
@@ -6,3 +6,4 @@ mod mask;
 pub(crate) mod rules;
 mod slice;
 mod take;
+mod zip;
diff --git a/vortex-array/src/arrays/listview/compute/zip.rs b/vortex-array/src/arrays/listview/compute/zip.rs
new file mode 100644
index 00000000000..1423a14804c
--- /dev/null
+++ b/vortex-array/src/arrays/listview/compute/zip.rs
@@ -0,0 +1,368 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::ops::BitAnd;
+use std::ops::BitOr;
+use std::ops::Not;
+
+use vortex_buffer::Buffer;
+use vortex_buffer::BufferMut;
+use vortex_error::VortexResult;
+use vortex_mask::Mask;
+
+use crate::ArrayRef;
+use crate::ExecutionCtx;
+use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Chunked;
+use crate::arrays::ChunkedArray;
+use crate::arrays::ListView;
+use crate::arrays::ListViewArray;
+use crate::arrays::chunked::ChunkedArrayExt;
+use crate::arrays::listview::ListViewArrayExt;
+use crate::builtins::ArrayBuiltins;
+use crate::dtype::DType;
+use crate::dtype::Nullability;
+use crate::dtype::PType;
+use crate::scalar_fn::fns::zip::ZipKernel;
+use crate::validity::Validity;
+
+/// Zip two [`ListViewArray`]s by selecting whole list views per row.
+///
+/// A [`ListViewArray`] addresses each list by an `(offset, size)` pair into a shared `elements`
+/// array, and unlike [`ListArray`](crate::arrays::ListArray) it does not require lists to be stored
+/// contiguously or in order. Zipping two list views is therefore a metadata-only operation over the
+/// `offsets`, `sizes` and `validity` child arrays: we concatenate the two `elements` arrays
+/// (without rewriting them) and, for each row, select the `(offset, size)` pair from `if_true` or
+/// `if_false` per the mask. `if_false` views are shifted past the end of `if_true`'s elements so
+/// they continue to address the correct half of the concatenated elements array.
+impl ZipKernel for ListView {
+    fn zip(
+        if_true: ArrayView<'_, ListView>,
+        if_false: &ArrayRef,
+        mask: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        let Some(if_false) = if_false.as_opt::<ListView>() else {
+            return Ok(None);
+        };
+
+        // Null mask entries select `if_false`, matching `Zip`'s SQL ELSE semantics.
+        let mask = mask.try_to_mask_fill_null_false(ctx)?;
+        match &mask {
+            // Defer the trivial masks to the generic zip, which just casts one side.
+            Mask::AllTrue(_) | Mask::AllFalse(_) => return Ok(None),
+            Mask::Values(_) => {}
+        }
+
+        let len = if_true.len();
+
+        let result_elements_dtype = if_true
+            .elements()
+            .dtype()
+            .union_nullability(if_false.elements().dtype().nullability());
+
+        // `if_false`'s elements share the element dtype up to nullability; normalize so both chunks
+        // of the concatenated elements array have an identical dtype.
+        let true_elements = if_true.elements().cast(result_elements_dtype.clone())?;
+        let false_elements = if_false.elements().cast(result_elements_dtype.clone())?;
+
+        // `if_false` views index into the second half of the concatenated elements.
+        let false_shift = true_elements.len() as u64;
+
+        // Concatenate the two `elements` arrays without copying. If either side is already a
+        // `ChunkedArray` (e.g. the result of a previous list-view zip), splice its chunks in
+        // directly rather than nesting chunked arrays.
+        let mut chunks = Vec::with_capacity(2);
+        push_element_chunks(true_elements, &mut chunks);
+        push_element_chunks(false_elements, &mut chunks);
+        let elements = ChunkedArray::try_new(chunks, result_elements_dtype)?.into_array();
+
+        let true_offsets = to_u64(if_true.offsets(), ctx)?;
+        let true_sizes = to_u64(if_true.sizes(), ctx)?;
+        let false_offsets = to_u64(if_false.offsets(), ctx)?;
+        let false_sizes = to_u64(if_false.sizes(), ctx)?;
+
+        let mut offsets = BufferMut::<u64>::with_capacity(len);
+        let mut sizes = BufferMut::<u64>::with_capacity(len);
+        for ((idx, (out_offsets, out_sizes)), selected) in offsets
+            .spare_capacity_mut()
+            .iter_mut()
+            .zip(sizes.spare_capacity_mut().iter_mut())
+            .take(len)
+            .enumerate()
+            .zip(mask.iter())
+        {
+            if selected {
+                out_offsets.write(true_offsets[idx]);
+                out_sizes.write(true_sizes[idx]);
+            } else {
+                out_offsets.write(false_offsets[idx] + false_shift);
+                out_sizes.write(false_sizes[idx]);
+            }
+        }
+
+        // SAFETY: the loop above initialized exactly `len` slots in both buffers.
+        unsafe {
+            offsets.set_len(len);
+            sizes.set_len(len);
+        }
+
+        let validity = zip_validity(if_true.validity()?, if_false.validity()?, &mask, ctx)?;
+
+        Ok(Some(
+            ListViewArray::try_new(
+                elements,
+                offsets.freeze().into_array(),
+                sizes.freeze().into_array(),
+                validity,
+            )?
+            .into_array(),
+        ))
+    }
+}
+
+/// Appends `array`'s element chunks to `chunks`, flattening a top-level [`ChunkedArray`] so the
+/// concatenated elements never nest chunked arrays.
+fn push_element_chunks(array: ArrayRef, chunks: &mut Vec<ArrayRef>) {
+    match array.as_opt::<Chunked>() {
+        Some(chunked) => chunks.extend(chunked.iter_chunks().cloned()),
+        None => chunks.push(array),
+    }
+}
+
+/// Read a non-nullable integer array into a `u64` buffer.
+fn to_u64(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Buffer<u64>> {
+    array
+        .clone()
+        .cast(DType::Primitive(PType::U64, Nullability::NonNullable))?
+        .execute::<Buffer<u64>>(ctx)
+}
+
+/// Combine the two list-level validities, taking `if_true`'s validity where `mask` is set and
+/// `if_false`'s where it is not.
+fn zip_validity(
+    if_true: Validity,
+    if_false: Validity,
+    mask: &Mask,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<Validity> {
+    Ok(match (&if_true, &if_false) {
+        (Validity::NonNullable, Validity::NonNullable) => Validity::NonNullable,
+        (Validity::AllValid, Validity::AllValid) => Validity::AllValid,
+        (Validity::AllInvalid, Validity::AllInvalid) => Validity::AllInvalid,
+        _ => {
+            let true_mask = if_true.execute_mask(mask.len(), ctx)?;
+            let false_mask = if_false.execute_mask(mask.len(), ctx)?;
+            let combined = true_mask
+                .bitand(mask)
+                .bitor(&false_mask.bitand(&mask.not()));
+            Validity::from_mask(combined, if_true.nullability() | if_false.nullability())
+        }
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
+    use vortex_mask::Mask;
+
+    use crate::ArrayRef;
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::arrays::BoolArray;
+    use crate::arrays::Chunked;
+    use crate::arrays::ChunkedArray;
+    use crate::arrays::ListView;
+    use crate::arrays::ListViewArray;
+    use crate::arrays::chunked::ChunkedArrayExt;
+    use crate::arrays::listview::ListViewArrayExt;
+    use crate::assert_arrays_eq;
+    use crate::builtins::ArrayBuiltins;
+    use crate::dtype::DType;
+    use crate::dtype::Nullability;
+    use crate::dtype::PType;
+    use crate::validity::Validity;
+
+    fn list_view(
+        elements: ArrayRef,
+        offsets: ArrayRef,
+        sizes: ArrayRef,
+        validity: Validity,
+    ) -> ArrayRef {
+        ListViewArray::try_new(elements, offsets, sizes, validity)
+            .unwrap()
+            .into_array()
+    }
+
+    /// `zip` of two list views selects whole lists per the mask and keeps the list encoding.
+    #[test]
+    fn zip_selects_lists() -> VortexResult<()> {
+        // [[1, 2], [3], [4, 5, 6]]
+        let if_true = list_view(
+            buffer![1i32, 2, 3, 4, 5, 6].into_array(),
+            buffer![0u32, 2, 3].into_array(),
+            buffer![2u32, 1, 3].into_array(),
+            Validity::NonNullable,
+        );
+        // [[10], [20, 21], [30]]
+        let if_false = list_view(
+            buffer![10i32, 20, 21, 30].into_array(),
+            buffer![0u32, 1, 3].into_array(),
+            buffer![1u32, 2, 1].into_array(),
+            Validity::NonNullable,
+        );
+        let mask = Mask::from_iter([true, false, true]);
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let result = mask
+            .into_array()
+            .zip(if_true, if_false)?
+            .execute::<ArrayRef>(&mut ctx)?;
+
+        // The kernel should keep the list-view encoding rather than canonicalizing.
+        assert!(result.is::<ListView>());
+
+        // Expected: [[1, 2], [20, 21], [4, 5, 6]]
+        let expected = list_view(
+            buffer![1i32, 2, 20, 21, 4, 5, 6].into_array(),
+            buffer![0u32, 2, 4].into_array(),
+            buffer![2u32, 2, 3].into_array(),
+            Validity::NonNullable,
+        );
+        assert_arrays_eq!(result, expected);
+        Ok(())
+    }
+
+    /// `zip` selects list-level validity from the chosen side and widens nullability.
+    #[test]
+    fn zip_selects_validity() -> VortexResult<()> {
+        // [[1], null, [2]] (list-level nulls)
+        let if_true = list_view(
+            buffer![1i32, 2].into_array(),
+            buffer![0u32, 1, 1].into_array(),
+            buffer![1u32, 0, 1].into_array(),
+            Validity::Array(BoolArray::from_iter([true, false, true]).into_array()),
+        );
+        // [[10], [20], null]
+        let if_false = list_view(
+            buffer![10i32, 20].into_array(),
+            buffer![0u32, 1, 2].into_array(),
+            buffer![1u32, 1, 0].into_array(),
+            Validity::Array(BoolArray::from_iter([true, true, false]).into_array()),
+        );
+        // true -> if_true, false -> if_false
+        let mask = Mask::from_iter([false, true, true]);
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let result = mask
+            .into_array()
+            .zip(if_true, if_false)?
+            .execute::<ArrayRef>(&mut ctx)?;
+
+        // Row 0 -> if_false[0] = [10]; row 1 -> if_true[1] = null; row 2 -> if_true[2] = [2]
+        let expected = list_view(
+            buffer![10i32, 2].into_array(),
+            buffer![0u32, 1, 1].into_array(),
+            buffer![1u32, 0, 1].into_array(),
+            Validity::Array(BoolArray::from_iter([true, false, true]).into_array()),
+        );
+        assert_arrays_eq!(result, expected);
+        Ok(())
+    }
+
+    /// `zip` handles out-of-order/non-contiguous offsets and widens nullability when only one side
+    /// is nullable.
+    #[test]
+    fn zip_out_of_order_offsets_and_widening() -> VortexResult<()> {
+        // [[5, 6], [7], [8, 9]] expressed with out-of-order offsets.
+        let if_true = list_view(
+            buffer![7i32, 8, 9, 5, 6].into_array(),
+            buffer![3u32, 0, 1].into_array(),
+            buffer![2u32, 1, 2].into_array(),
+            Validity::NonNullable,
+        );
+        // [[100], null, [200, 201]]
+        let if_false = list_view(
+            buffer![100i32, 200, 201].into_array(),
+            buffer![0u32, 1, 1].into_array(),
+            buffer![1u32, 0, 2].into_array(),
+            Validity::Array(BoolArray::from_iter([true, false, true]).into_array()),
+        );
+        let mask = Mask::from_iter([true, true, false]);
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let result = mask
+            .into_array()
+            .zip(if_true, if_false)?
+            .execute::<ArrayRef>(&mut ctx)?;
+        assert!(result.is::<ListView>());
+
+        // [[5, 6], [7], [200, 201]], all valid but nullable (widened by if_false).
+        let expected = list_view(
+            buffer![5i32, 6, 7, 200, 201].into_array(),
+            buffer![0u32, 2, 3].into_array(),
+            buffer![2u32, 1, 2].into_array(),
+            Validity::AllValid,
+        );
+        assert_arrays_eq!(result, expected);
+        Ok(())
+    }
+
+    /// When an input's `elements` is already a [`ChunkedArray`], its chunks are spliced in rather
+    /// than nesting a chunked array inside the concatenated elements.
+    #[test]
+    fn zip_flattens_chunked_elements() -> VortexResult<()> {
+        // elements [1, 2, 3] stored as two chunks; lists [[1, 2], [3]].
+        let chunked_elements = ChunkedArray::try_new(
+            vec![buffer![1i32, 2].into_array(), buffer![3i32].into_array()],
+            DType::Primitive(PType::I32, Nullability::NonNullable),
+        )?
+        .into_array();
+        let if_true = list_view(
+            chunked_elements,
+            buffer![0u32, 2].into_array(),
+            buffer![2u32, 1].into_array(),
+            Validity::NonNullable,
+        );
+        // [[10], [20]]
+        let if_false = list_view(
+            buffer![10i32, 20].into_array(),
+            buffer![0u32, 1].into_array(),
+            buffer![1u32, 1].into_array(),
+            Validity::NonNullable,
+        );
+        let mask = Mask::from_iter([true, false]);
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let result = mask
+            .into_array()
+            .zip(if_true, if_false)?
+            .execute::<ArrayRef>(&mut ctx)?;
+
+        // The concatenated elements are chunked, but no chunk is itself a `ChunkedArray`.
+        let result_lv = result
+            .as_opt::<ListView>()
+            .expect("zip keeps the list-view encoding");
+        let chunked = result_lv
+            .elements()
+            .as_opt::<Chunked>()
+            .expect("zip concatenates elements into a chunked array");
+        assert!(
+            chunked.iter_chunks().all(|chunk| !chunk.is::<Chunked>()),
+            "chunked elements must be flattened, not nested",
+        );
+
+        // [[1, 2], [20]]
+        let expected = list_view(
+            buffer![1i32, 2, 20].into_array(),
+            buffer![0u32, 2].into_array(),
+            buffer![2u32, 1].into_array(),
+            Validity::NonNullable,
+        );
+        assert_arrays_eq!(result, expected);
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/arrays/listview/conversion.rs b/vortex-array/src/arrays/listview/conversion.rs
index 54ee8c2705c..7b553041c68 100644
--- a/vortex-array/src/arrays/listview/conversion.rs
+++ b/vortex-array/src/arrays/listview/conversion.rs
@@ -8,8 +8,6 @@ use crate::ArrayRef;
 use crate::Canonical;
 use crate::ExecutionCtx;
 use crate::IntoArray;
-#[expect(deprecated)]
-use crate::ToCanonical as _;
 use crate::arrays::ExtensionArray;
 use crate::arrays::FixedSizeListArray;
 use crate::arrays::ListArray;
@@ -29,8 +27,8 @@ use crate::match_each_integer_ptype;
 
 /// Creates a `ListViewArray` from a `ListArray` by computing `sizes` from `offsets`.
 ///
-/// The output `ListViewArray` will be zero-copyable back to a `ListArray`, and additionally it
-/// will not have any leading or trailing garbage data.
+/// The output `ListViewArray` will be zero-copyable back to a `ListArray`, and additionally it will
+/// not have any leading or trailing garbage data.
 pub fn list_view_from_list(list: ListArray, ctx: &mut ExecutionCtx) -> VortexResult<ListViewArray> {
     // If the list is empty, create an empty `ListViewArray` with the same offset `DType` as the
     // input.
@@ -41,8 +39,7 @@ pub fn list_view_from_list(list: ListArray, ctx: &mut ExecutionCtx) -> VortexRes
     // We reset the offsets here because mostly for convenience, and also because callers of this
     // function might not expect the output `ListViewArray` to have a bunch of leading and trailing
     // garbage data when they turn it back into a `ListArray`.
-    let list = list.reset_offsets(false).vortex_expect("This can't fail");
-
+    let list = list.reset_offsets(false, ctx)?;
     let list_offsets = list.offsets().clone();
 
     // Create `sizes` array by computing differences between consecutive offsets.
@@ -108,15 +105,18 @@ fn build_sizes_from_offsets<O: IntegerPType>(
 ///
 /// Otherwise, this function fall back to the (very) expensive path and will rebuild the
 /// `ListArray` from scratch.
-pub fn list_from_list_view(list_view: ListViewArray) -> VortexResult<ListArray> {
+pub fn list_from_list_view(
+    list_view: ListViewArray,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ListArray> {
     // Rebuild as zero-copyable to list array and also trim all leading and trailing elements.
-    let zctl_array = list_view.rebuild(ListViewRebuildMode::MakeExact)?;
+    let zctl_array = list_view.rebuild(ListViewRebuildMode::MakeExact, ctx)?;
     debug_assert!(zctl_array.is_zero_copy_to_list());
 
     let list_offsets = match_each_integer_ptype!(zctl_array.offsets().dtype().as_ptype(), |O| {
         // SAFETY: We just made the array zero-copyable to `ListArray`, so the safety contract is
         // upheld.
-        unsafe { build_list_offsets_from_list_view::<O>(&zctl_array) }
+        unsafe { build_list_offsets_from_list_view::<O>(&zctl_array, ctx) }
     });
 
     // SAFETY: Because the shape of the `ListViewArray` is zero-copyable to a `ListArray`, we
@@ -142,6 +142,7 @@ pub fn list_from_list_view(list_view: ListViewArray) -> VortexResult<ListArray>
 /// between `offset[i]` and `offset[i + 1]`.
 unsafe fn build_list_offsets_from_list_view<O: IntegerPType>(
     list_view: &ListViewArray,
+    ctx: &mut ExecutionCtx,
 ) -> ArrayRef {
     let len = list_view.len();
     let mut offsets_builder =
@@ -150,8 +151,11 @@ unsafe fn build_list_offsets_from_list_view<O: IntegerPType>(
     // Create uninit range for direct memory access.
     let mut offsets_range = offsets_builder.uninit_range(len + 1);
 
-    #[expect(deprecated)]
-    let offsets = list_view.offsets().to_primitive();
+    let offsets = list_view
+        .offsets()
+        .clone()
+        .execute::<PrimitiveArray>(ctx)
+        .vortex_expect("list view offsets must be primitive after rebuild");
     let offsets_slice = offsets.as_slice::<O>();
     debug_assert!(offsets_slice.is_sorted());
 
@@ -184,17 +188,20 @@ unsafe fn build_list_offsets_from_list_view<O: IntegerPType>(
 /// Recursively converts all `ListViewArray`s to `ListArray`s in a nested array structure.
 ///
 /// The conversion happens bottom-up, processing children before parents.
-pub fn recursive_list_from_list_view(array: ArrayRef) -> VortexResult<ArrayRef> {
+pub fn recursive_list_from_list_view(
+    array: ArrayRef,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ArrayRef> {
     if !array.dtype().is_nested() {
         return Ok(array);
     }
 
-    #[expect(deprecated)]
-    let canonical = array.to_canonical()?;
+    let canonical = array.execute::<Canonical>(ctx)?;
 
     Ok(match canonical {
         Canonical::List(listview) => {
-            let converted_elements = recursive_list_from_list_view(listview.elements().clone())?;
+            let converted_elements =
+                recursive_list_from_list_view(listview.elements().clone(), ctx)?;
             debug_assert_eq!(converted_elements.len(), listview.elements().len());
 
             // Avoid cloning if elements didn't change.
@@ -216,12 +223,12 @@ pub fn recursive_list_from_list_view(array: ArrayRef) -> VortexResult<ArrayRef>
                 };
 
             // Make the conversion to `ListArray`.
-            let list_array = list_from_list_view(listview_with_converted_elements)?;
+            let list_array = list_from_list_view(listview_with_converted_elements, ctx)?;
             list_array.into_array()
         }
         Canonical::FixedSizeList(fixed_size_list) => {
             let converted_elements =
-                recursive_list_from_list_view(fixed_size_list.elements().clone())?;
+                recursive_list_from_list_view(fixed_size_list.elements().clone(), ctx)?;
 
             // Avoid cloning if elements didn't change.
             if !ArrayRef::ptr_eq(&converted_elements, fixed_size_list.elements()) {
@@ -245,7 +252,7 @@ pub fn recursive_list_from_list_view(array: ArrayRef) -> VortexResult<ArrayRef>
             let mut any_changed = false;
 
             for field in fields.iter() {
-                let converted_field = recursive_list_from_list_view(field.clone())?;
+                let converted_field = recursive_list_from_list_view(field.clone(), ctx)?;
                 // Avoid cloning if elements didn't change.
                 any_changed |= !ArrayRef::ptr_eq(&converted_field, field);
                 converted_fields.push(converted_field);
@@ -266,7 +273,7 @@ pub fn recursive_list_from_list_view(array: ArrayRef) -> VortexResult<ArrayRef>
         }
         Canonical::Extension(ext_array) => {
             let converted_storage =
-                recursive_list_from_list_view(ext_array.storage_array().clone())?;
+                recursive_list_from_list_view(ext_array.storage_array().clone(), ctx)?;
 
             // Avoid cloning if elements didn't change.
             if !ArrayRef::ptr_eq(&converted_storage, ext_array.storage_array()) {
@@ -286,6 +293,7 @@ mod tests {
     use vortex_error::VortexExpect;
     use vortex_error::VortexResult;
 
+    use super::super::tests::common::SESSION;
     use super::super::tests::common::create_basic_listview;
     use super::super::tests::common::create_empty_lists_listview;
     use super::super::tests::common::create_nullable_listview;
@@ -293,9 +301,8 @@ mod tests {
     use super::recursive_list_from_list_view;
     use crate::ArrayEq;
     use crate::ArrayRef;
+    use crate::EqMode;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
-    use crate::Precision;
     use crate::VortexSessionExecute;
     use crate::arrays::BoolArray;
     use crate::arrays::FixedSizeListArray;
@@ -319,7 +326,7 @@ mod tests {
         let offsets = buffer![0u32, 3, 5, 7, 10].into_array();
         let list_array = ListArray::try_new(elements.clone(), offsets, Validity::NonNullable)?;
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let list_view = list_view_from_list(list_array.clone(), &mut ctx)?;
 
         // Verify structure.
@@ -342,7 +349,8 @@ mod tests {
     #[test]
     fn test_listview_to_list_zero_copy() -> VortexResult<()> {
         let list_view = create_basic_listview();
-        let list_array = list_from_list_view(list_view.clone())?;
+        let list_array =
+            list_from_list_view(list_view.clone(), &mut SESSION.create_execution_ctx())?;
 
         // Should have same elements.
         assert_arrays_eq!(list_view.elements().clone(), list_array.elements().clone());
@@ -366,12 +374,12 @@ mod tests {
 
         // This conversion will create an empty ListViewArray.
         // Note: list_view_from_list handles the empty case specially.
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let empty_list_view = list_view_from_list(empty_list.clone(), &mut ctx)?;
         assert_eq!(empty_list_view.len(), 0);
 
         // Convert back.
-        let converted_back = list_from_list_view(empty_list_view)?;
+        let converted_back = list_from_list_view(empty_list_view, &mut ctx)?;
         assert_eq!(converted_back.len(), 0);
         // For empty arrays, we can't use assert_arrays_eq directly since the offsets might differ.
         // Just check that it's empty.
@@ -387,7 +395,7 @@ mod tests {
         let validity = Validity::Array(BoolArray::from_iter(vec![true, false, true]).into_array());
         let nullable_list = ListArray::try_new(elements, offsets, validity.clone())?;
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let nullable_list_view = list_view_from_list(nullable_list.clone(), &mut ctx)?;
 
         // Verify validity is preserved.
@@ -395,12 +403,12 @@ mod tests {
             nullable_list_view
                 .validity()
                 .vortex_expect("listview validity should be derivable")
-                .array_eq(&validity, Precision::Ptr)
+                .array_eq(&validity, EqMode::Ptr)
         );
         assert_eq!(nullable_list_view.len(), 3);
 
         // Round-trip conversion.
-        let converted_back = list_from_list_view(nullable_list_view)?;
+        let converted_back = list_from_list_view(nullable_list_view, &mut ctx)?;
         assert_arrays_eq!(nullable_list, converted_back);
         Ok(())
     }
@@ -409,7 +417,8 @@ mod tests {
     fn test_non_zero_copy_listview_to_list() -> VortexResult<()> {
         // Create ListViewArray with overlapping lists (not zero-copyable).
         let list_view = create_overlapping_listview();
-        let list_array = list_from_list_view(list_view.clone())?;
+        let list_array =
+            list_from_list_view(list_view.clone(), &mut SESSION.create_execution_ctx())?;
 
         // The resulting ListArray should have monotonic offsets.
         for i in 0..list_array.len() {
@@ -425,10 +434,11 @@ mod tests {
 
     #[test]
     fn test_empty_sublists() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
         let empty_lists_view = create_empty_lists_listview();
 
         // Convert to ListArray.
-        let list_array = list_from_list_view(empty_lists_view.clone())?;
+        let list_array = list_from_list_view(empty_lists_view.clone(), &mut ctx)?;
         assert_eq!(list_array.len(), 4);
 
         // All sublists should be empty.
@@ -437,7 +447,6 @@ mod tests {
         }
 
         // Round-trip.
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let converted_back = list_view_from_list(list_array, &mut ctx)?;
         assert_arrays_eq!(empty_lists_view, converted_back);
         Ok(())
@@ -451,7 +460,7 @@ mod tests {
         let list_i32 =
             ListArray::try_new(elements.clone(), i32_offsets.clone(), Validity::NonNullable)?;
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let list_view_i32 = list_view_from_list(list_i32.clone(), &mut ctx)?;
         assert_eq!(list_view_i32.offsets().dtype(), i32_offsets.dtype());
         assert_eq!(list_view_i32.sizes().dtype(), i32_offsets.dtype());
@@ -472,24 +481,24 @@ mod tests {
 
     #[test]
     fn test_round_trip_conversions() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
 
         // Test 1: Basic round-trip.
         let original = create_basic_listview();
-        let to_list = list_from_list_view(original.clone())?;
+        let to_list = list_from_list_view(original.clone(), &mut ctx)?;
         let back_to_view = list_view_from_list(to_list, &mut ctx)?;
         assert_arrays_eq!(original, back_to_view);
 
         // Test 2: Nullable round-trip.
         let nullable = create_nullable_listview();
-        let nullable_to_list = list_from_list_view(nullable.clone())?;
+        let nullable_to_list = list_from_list_view(nullable.clone(), &mut ctx)?;
         let nullable_back = list_view_from_list(nullable_to_list, &mut ctx)?;
         assert_arrays_eq!(nullable, nullable_back);
 
         // Test 3: Non-zero-copyable round-trip.
         let overlapping = create_overlapping_listview();
 
-        let overlapping_to_list = list_from_list_view(overlapping.clone())?;
+        let overlapping_to_list = list_from_list_view(overlapping.clone(), &mut ctx)?;
         let overlapping_back = list_view_from_list(overlapping_to_list, &mut ctx)?;
         assert_arrays_eq!(overlapping, overlapping_back);
         Ok(())
@@ -502,7 +511,7 @@ mod tests {
         let offsets = buffer![0u32, 1, 2, 3].into_array();
         let single_elem_list = ListArray::try_new(elements, offsets, Validity::NonNullable)?;
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let list_view = list_view_from_list(single_elem_list.clone(), &mut ctx)?;
         assert_eq!(list_view.len(), 3);
 
@@ -511,7 +520,7 @@ mod tests {
         assert_arrays_eq!(expected_sizes, list_view.sizes().clone());
 
         // Round-trip.
-        let converted_back = list_from_list_view(list_view)?;
+        let converted_back = list_from_list_view(list_view, &mut ctx)?;
         assert_arrays_eq!(single_elem_list, converted_back);
         Ok(())
     }
@@ -523,7 +532,7 @@ mod tests {
         let offsets = buffer![0u32, 2, 2, 3, 3, 6].into_array();
         let mixed_list = ListArray::try_new(elements, offsets, Validity::NonNullable)?;
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let list_view = list_view_from_list(mixed_list.clone(), &mut ctx)?;
         assert_eq!(list_view.len(), 5);
 
@@ -532,7 +541,7 @@ mod tests {
         assert_arrays_eq!(expected_sizes, list_view.sizes().clone());
 
         // Round-trip.
-        let converted_back = list_from_list_view(list_view)?;
+        let converted_back = list_from_list_view(list_view, &mut ctx)?;
         assert_arrays_eq!(mixed_list, converted_back);
         Ok(())
     }
@@ -540,7 +549,10 @@ mod tests {
     #[test]
     fn test_recursive_simple_listview() -> VortexResult<()> {
         let list_view = create_basic_listview();
-        let result = recursive_list_from_list_view(list_view.clone().into_array())?;
+        let result = recursive_list_from_list_view(
+            list_view.clone().into_array(),
+            &mut SESSION.create_execution_ctx(),
+        )?;
 
         assert_eq!(result.len(), list_view.len());
         assert_arrays_eq!(list_view.into_array(), result);
@@ -574,7 +586,10 @@ mod tests {
             .with_zero_copy_to_list(true)
         };
 
-        let result = recursive_list_from_list_view(outer_listview.clone().into_array())?;
+        let result = recursive_list_from_list_view(
+            outer_listview.clone().into_array(),
+            &mut SESSION.create_execution_ctx(),
+        )?;
 
         assert_eq!(result.len(), 2);
         assert_arrays_eq!(outer_listview.into_array(), result);
@@ -593,7 +608,10 @@ mod tests {
             Validity::NonNullable,
         )?;
 
-        let result = recursive_list_from_list_view(struct_array.clone().into_array())?;
+        let result = recursive_list_from_list_view(
+            struct_array.clone().into_array(),
+            &mut SESSION.create_execution_ctx(),
+        )?;
 
         assert_eq!(result.len(), 4);
         assert_arrays_eq!(struct_array.into_array(), result);
@@ -635,7 +653,10 @@ mod tests {
         let fixed_list =
             FixedSizeListArray::new(chunked_listviews.into_array(), 1, Validity::NonNullable, 2);
 
-        let result = recursive_list_from_list_view(fixed_list.clone().into_array())?;
+        let result = recursive_list_from_list_view(
+            fixed_list.clone().into_array(),
+            &mut SESSION.create_execution_ctx(),
+        )?;
 
         assert_eq!(result.len(), 2);
         assert_arrays_eq!(fixed_list.into_array(), result);
@@ -676,7 +697,10 @@ mod tests {
             .with_zero_copy_to_list(true)
         };
 
-        let result = recursive_list_from_list_view(outer_listview.clone().into_array())?;
+        let result = recursive_list_from_list_view(
+            outer_listview.clone().into_array(),
+            &mut SESSION.create_execution_ctx(),
+        )?;
 
         assert_eq!(result.len(), 2);
         assert_arrays_eq!(outer_listview.into_array(), result);
@@ -687,7 +711,7 @@ mod tests {
     fn test_recursive_primitive_unchanged() -> VortexResult<()> {
         let prim = buffer![1i32, 2, 3].into_array();
         let prim_clone = prim.clone();
-        let result = recursive_list_from_list_view(prim)?;
+        let result = recursive_list_from_list_view(prim, &mut SESSION.create_execution_ctx())?;
 
         assert!(ArrayRef::ptr_eq(&result, &prim_clone));
         Ok(())
@@ -695,8 +719,9 @@ mod tests {
 
     #[test]
     fn test_recursive_mixed_listview_and_list() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
         let listview = create_basic_listview();
-        let list = list_from_list_view(listview.clone())?;
+        let list = list_from_list_view(listview.clone(), &mut ctx)?;
 
         let struct_array = StructArray::try_new(
             FieldNames::from(["listview_field", "list_field"]),
@@ -705,7 +730,7 @@ mod tests {
             Validity::NonNullable,
         )?;
 
-        let result = recursive_list_from_list_view(struct_array.clone().into_array())?;
+        let result = recursive_list_from_list_view(struct_array.clone().into_array(), &mut ctx)?;
 
         assert_eq!(result.len(), 4);
         assert_arrays_eq!(struct_array.into_array(), result);
@@ -727,7 +752,7 @@ mod tests {
         // `try_new` sets `is_zero_copy_to_list: false`.
         assert!(!list_view.is_zero_copy_to_list());
 
-        let list_array = list_from_list_view(list_view)?;
+        let list_array = list_from_list_view(list_view, &mut SESSION.create_execution_ctx())?;
         assert_eq!(list_array.len(), 0);
         Ok(())
     }
diff --git a/vortex-array/src/arrays/listview/rebuild.rs b/vortex-array/src/arrays/listview/rebuild.rs
index 2bcb4ef0c1f..7ef752e4dcb 100644
--- a/vortex-array/src/arrays/listview/rebuild.rs
+++ b/vortex-array/src/arrays/listview/rebuild.rs
@@ -6,11 +6,9 @@ use vortex_buffer::BufferMut;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
+use crate::Canonical;
+use crate::ExecutionCtx;
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
-#[expect(deprecated)]
-use crate::ToCanonical as _;
-use crate::VortexSessionExecute;
 use crate::arrays::ConstantArray;
 use crate::arrays::ListViewArray;
 use crate::arrays::PrimitiveArray;
@@ -99,16 +97,20 @@ pub enum ListViewRebuildMode {
 
 impl ListViewArray {
     /// Rebuilds the [`ListViewArray`] according to the specified mode.
-    pub fn rebuild(&self, mode: ListViewRebuildMode) -> VortexResult<ListViewArray> {
+    pub fn rebuild(
+        &self,
+        mode: ListViewRebuildMode,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ListViewArray> {
         if self.is_empty() {
             // SAFETY: An empty array is trivially zero-copyable to a `ListArray`.
             return Ok(unsafe { self.clone().with_zero_copy_to_list(true) });
         }
 
         match mode {
-            ListViewRebuildMode::MakeZeroCopyToList => self.rebuild_zero_copy_to_list(),
-            ListViewRebuildMode::TrimElements => self.rebuild_trim_elements(),
-            ListViewRebuildMode::MakeExact => self.rebuild_make_exact(),
+            ListViewRebuildMode::MakeZeroCopyToList => self.rebuild_zero_copy_to_list(ctx),
+            ListViewRebuildMode::TrimElements => self.rebuild_trim_elements(ctx),
+            ListViewRebuildMode::MakeExact => self.rebuild_make_exact(ctx),
             ListViewRebuildMode::OverlapCompression => unimplemented!("Does P=NP?"),
         }
     }
@@ -120,7 +122,7 @@ impl ListViewArray {
     /// a [`ListArray`].
     ///
     /// [`ListArray`]: crate::arrays::ListArray
-    fn rebuild_zero_copy_to_list(&self) -> VortexResult<ListViewArray> {
+    fn rebuild_zero_copy_to_list(&self, ctx: &mut ExecutionCtx) -> VortexResult<ListViewArray> {
         if self.is_zero_copy_to_list() {
             // Note that since everything in `ListViewArray` is `Arc`ed, this is quite cheap.
             return Ok(self.clone());
@@ -138,10 +140,10 @@ impl ListViewArray {
         // for sizes as well.
         match_each_unsigned_integer_ptype!(sizes_ptype.to_unsigned(), |S| {
             match offsets_ptype.to_unsigned() {
-                PType::U8 => self.naive_rebuild::<u8, u32, S>(),
-                PType::U16 => self.naive_rebuild::<u16, u32, S>(),
-                PType::U32 => self.naive_rebuild::<u32, u32, S>(),
-                PType::U64 => self.naive_rebuild::<u64, u64, S>(),
+                PType::U8 => self.naive_rebuild::<u8, u32, S>(ctx),
+                PType::U16 => self.naive_rebuild::<u16, u32, S>(ctx),
+                PType::U32 => self.naive_rebuild::<u32, u32, S>(ctx),
+                PType::U64 => self.naive_rebuild::<u64, u64, S>(ctx),
                 _ => unreachable!("invalid offsets PType"),
             }
         })
@@ -152,9 +154,9 @@ impl ListViewArray {
     /// list size.
     fn naive_rebuild<O: IntegerPType, NewOffset: IntegerPType, S: IntegerPType>(
         &self,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<ListViewArray> {
-        #[expect(deprecated)]
-        let sizes_canonical = self.sizes().to_primitive();
+        let sizes_canonical = self.sizes().clone().execute::<PrimitiveArray>(ctx)?;
         let sizes_canonical =
             sizes_canonical.reinterpret_cast(sizes_canonical.ptype().to_unsigned());
         let total: u64 = sizes_canonical
@@ -163,9 +165,9 @@ impl ListViewArray {
             .map(|s| (*s).as_() as u64)
             .sum();
         if Self::should_use_take(total, self.len()) {
-            self.rebuild_with_take::<O, NewOffset, S>()
+            self.rebuild_with_take::<O, NewOffset, S>(ctx)
         } else {
-            self.rebuild_list_by_list::<O, NewOffset, S>()
+            self.rebuild_list_by_list::<O, NewOffset, S>(ctx)
         }
     }
 
@@ -188,17 +190,16 @@ impl ListViewArray {
     /// `BufferMut<u64>`, perform a single `take`.
     fn rebuild_with_take<O: IntegerPType, NewOffset: IntegerPType, S: IntegerPType>(
         &self,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<ListViewArray> {
         let new_offset_ptype = rebuilt_offset_ptype(self.offsets().dtype().as_ptype());
         let size_ptype = self.sizes().dtype().as_ptype();
 
-        #[expect(deprecated)]
-        let offsets_canonical = self.offsets().to_primitive();
+        let offsets_canonical = self.offsets().clone().execute::<PrimitiveArray>(ctx)?;
         let offsets_canonical =
             offsets_canonical.reinterpret_cast(offsets_canonical.ptype().to_unsigned());
         let offsets_slice = offsets_canonical.as_slice::<O>();
-        #[expect(deprecated)]
-        let sizes_canonical = self.sizes().to_primitive();
+        let sizes_canonical = self.sizes().clone().execute::<PrimitiveArray>(ctx)?;
         let sizes_canonical =
             sizes_canonical.reinterpret_cast(sizes_canonical.ptype().to_unsigned());
         let sizes_slice = sizes_canonical.as_slice::<S>();
@@ -209,9 +210,14 @@ impl ListViewArray {
         let mut new_sizes = BufferMut::<S>::with_capacity(len);
         let mut take_indices = BufferMut::<u64>::with_capacity(self.elements().len());
 
+        // Resolve validity to a mask once instead of probing it per row: `execute_is_valid`
+        // executes a scalar on every call for array-backed validity, which is O(len) work repeated
+        // `len` times.
+        let validity = self.validity()?.execute_mask(len, ctx)?;
+
         let mut n_elements = NewOffset::zero();
         for index in 0..len {
-            if !self.validity()?.is_valid(index)? {
+            if !validity.value(index) {
                 new_offsets.push(n_elements);
                 new_sizes.push(S::zero());
                 continue;
@@ -250,6 +256,7 @@ impl ListViewArray {
     /// the relevant range and `extend_from_array` into a typed builder.
     fn rebuild_list_by_list<O: IntegerPType, NewOffset: IntegerPType, S: IntegerPType>(
         &self,
+        ctx: &mut ExecutionCtx,
     ) -> VortexResult<ListViewArray> {
         let element_dtype = self
             .dtype()
@@ -259,13 +266,11 @@ impl ListViewArray {
         let new_offset_ptype = rebuilt_offset_ptype(self.offsets().dtype().as_ptype());
         let size_ptype = self.sizes().dtype().as_ptype();
 
-        #[expect(deprecated)]
-        let offsets_canonical = self.offsets().to_primitive();
+        let offsets_canonical = self.offsets().clone().execute::<PrimitiveArray>(ctx)?;
         let offsets_canonical =
             offsets_canonical.reinterpret_cast(offsets_canonical.ptype().to_unsigned());
         let offsets_slice = offsets_canonical.as_slice::<O>();
-        #[expect(deprecated)]
-        let sizes_canonical = self.sizes().to_primitive();
+        let sizes_canonical = self.sizes().clone().execute::<PrimitiveArray>(ctx)?;
         let sizes_canonical =
             sizes_canonical.reinterpret_cast(sizes_canonical.ptype().to_unsigned());
         let sizes_slice = sizes_canonical.as_slice::<S>();
@@ -280,11 +285,10 @@ impl ListViewArray {
         let mut new_sizes = BufferMut::<S>::with_capacity(len);
 
         // Canonicalize the elements up front as we will be slicing the elements quite a lot.
-        #[expect(deprecated)]
         let elements_canonical = self
             .elements()
-            .to_canonical()
-            .vortex_expect("canonicalize elements for rebuild")
+            .clone()
+            .execute::<Canonical>(ctx)?
             .into_array();
 
         // Note that we do not know what the exact capacity should be of the new elements since
@@ -292,9 +296,12 @@ impl ListViewArray {
         let mut new_elements_builder =
             builder_with_capacity(element_dtype.as_ref(), self.elements().len());
 
+        // Resolve validity to a mask once instead of probing it per row (see `rebuild_with_take`).
+        let validity = self.validity()?.execute_mask(len, ctx)?;
+
         let mut n_elements = NewOffset::zero();
         for index in 0..len {
-            if !self.validity()?.is_valid(index)? {
+            if !validity.value(index) {
                 // For NULL lists, place them after the previous item's data to maintain the
                 // no-overlap invariant for zero-copy to `ListArray` arrays.
                 new_offsets.push(n_elements);
@@ -347,9 +354,8 @@ impl ListViewArray {
     /// Rebuilds a [`ListViewArray`] by trimming any unused / unreferenced leading and trailing
     /// elements, which is defined as a contiguous run of values in the `elements` array that are
     /// not referenced by any views in the corresponding [`ListViewArray`].
-    fn rebuild_trim_elements(&self) -> VortexResult<ListViewArray> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
-        let (start, end) = self.referenced_element_bounds(&mut ctx)?;
+    fn rebuild_trim_elements(&self, ctx: &mut ExecutionCtx) -> VortexResult<ListViewArray> {
+        let (start, end) = self.referenced_element_bounds(ctx)?;
 
         // SAFETY: we calculated valid start and end bounds
         unsafe { self.trim_elements(start, end) }
@@ -395,13 +401,13 @@ impl ListViewArray {
         })
     }
 
-    fn rebuild_make_exact(&self) -> VortexResult<ListViewArray> {
+    fn rebuild_make_exact(&self, ctx: &mut ExecutionCtx) -> VortexResult<ListViewArray> {
         if self.is_zero_copy_to_list() {
-            self.rebuild_trim_elements()
+            self.rebuild_trim_elements(ctx)
         } else {
             // When we completely rebuild the `ListViewArray`, we get the benefit that we also trim
             // any leading and trailing garbage data.
-            self.rebuild_zero_copy_to_list()
+            self.rebuild_zero_copy_to_list(ctx)
         }
     }
 }
@@ -411,11 +417,9 @@ mod tests {
     use vortex_buffer::BitBuffer;
     use vortex_error::VortexResult;
 
+    use super::super::tests::common::SESSION;
     use super::ListViewRebuildMode;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
-    #[expect(deprecated)]
-    use crate::ToCanonical as _;
     use crate::VortexSessionExecute;
     use crate::arrays::ListViewArray;
     use crate::arrays::PrimitiveArray;
@@ -435,7 +439,8 @@ mod tests {
 
         let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable);
 
-        let flattened = listview.rebuild(ListViewRebuildMode::MakeZeroCopyToList)?;
+        let mut ctx = SESSION.create_execution_ctx();
+        let flattened = listview.rebuild(ListViewRebuildMode::MakeZeroCopyToList, &mut ctx)?;
 
         // After flatten: elements should be [A, B, C, B, C] = [1, 2, 3, 2, 3]
         // Lists should be sequential with no overlaps
@@ -478,13 +483,14 @@ mod tests {
 
         let listview = ListViewArray::new(elements, offsets, sizes, validity);
 
-        let flattened = listview.rebuild(ListViewRebuildMode::MakeZeroCopyToList)?;
+        let mut ctx = SESSION.create_execution_ctx();
+        let flattened = listview.rebuild(ListViewRebuildMode::MakeZeroCopyToList, &mut ctx)?;
 
         // Verify nullability is preserved
         assert_eq!(flattened.dtype().nullability(), Nullability::Nullable);
-        assert!(flattened.validity()?.is_valid(0)?);
-        assert!(!flattened.validity()?.is_valid(1)?);
-        assert!(flattened.validity()?.is_valid(2)?);
+        assert!(flattened.validity()?.execute_is_valid(0, &mut ctx)?);
+        assert!(!flattened.validity()?.execute_is_valid(1, &mut ctx)?);
+        assert!(flattened.validity()?.execute_is_valid(2, &mut ctx)?);
 
         // Verify valid lists contain correct data
         assert_arrays_eq!(
@@ -515,7 +521,8 @@ mod tests {
 
         let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable);
 
-        let trimmed = listview.rebuild(ListViewRebuildMode::TrimElements)?;
+        let mut ctx = SESSION.create_execution_ctx();
+        let trimmed = listview.rebuild(ListViewRebuildMode::TrimElements, &mut ctx)?;
 
         // After trimming: elements should be [A, B, _, C, D] = [1, 2, 97, 3, 4].
         assert_eq!(trimmed.elements().len(), 5);
@@ -538,12 +545,11 @@ mod tests {
         );
 
         // Note that element at index 2 (97) is preserved as a gap.
-        #[expect(deprecated)]
-        let all_elements = trimmed.elements().to_primitive();
-        assert_eq!(
-            all_elements.execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())?,
-            97i32.into()
-        );
+        let all_elements = trimmed
+            .elements()
+            .clone()
+            .execute::<PrimitiveArray>(&mut ctx)?;
+        assert_eq!(all_elements.execute_scalar(2, &mut ctx)?, 97i32.into());
         Ok(())
     }
 
@@ -562,7 +568,8 @@ mod tests {
         let listview = ListViewArray::new(elements, offsets, sizes, validity);
 
         // First rebuild to make it zero-copy-to-list
-        let rebuilt = listview.rebuild(ListViewRebuildMode::MakeZeroCopyToList)?;
+        let mut ctx = SESSION.create_execution_ctx();
+        let rebuilt = listview.rebuild(ListViewRebuildMode::MakeZeroCopyToList, &mut ctx)?;
         assert!(rebuilt.is_zero_copy_to_list());
 
         // Verify NULL items have correct offsets (should not reuse previous offsets)
@@ -580,13 +587,13 @@ mod tests {
 
         // Now rebuild with MakeExact (which calls naive_rebuild then trim_elements)
         // This should not panic (issue #5412)
-        let exact = rebuilt.rebuild(ListViewRebuildMode::MakeExact)?;
+        let exact = rebuilt.rebuild(ListViewRebuildMode::MakeExact, &mut ctx)?;
 
         // Verify the result is still valid
-        assert!(exact.is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())?);
-        assert!(exact.is_valid(1, &mut LEGACY_SESSION.create_execution_ctx())?);
-        assert!(!exact.is_valid(2, &mut LEGACY_SESSION.create_execution_ctx())?);
-        assert!(!exact.is_valid(3, &mut LEGACY_SESSION.create_execution_ctx())?);
+        assert!(exact.is_valid(0, &mut ctx)?);
+        assert!(exact.is_valid(1, &mut ctx)?);
+        assert!(!exact.is_valid(2, &mut ctx)?);
+        assert!(!exact.is_valid(3, &mut ctx)?);
 
         // Verify data is preserved
         assert_arrays_eq!(
@@ -615,7 +622,8 @@ mod tests {
         let sizes = PrimitiveArray::from_iter(vec![2u16, 2]).into_array();
 
         let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable);
-        let trimmed = listview.rebuild(ListViewRebuildMode::TrimElements)?;
+        let mut ctx = SESSION.create_execution_ctx();
+        let trimmed = listview.rebuild(ListViewRebuildMode::TrimElements, &mut ctx)?;
         assert_arrays_eq!(
             trimmed.list_elements_at(1)?,
             PrimitiveArray::from_iter([30i32, 40])
@@ -635,7 +643,8 @@ mod tests {
         let sizes = PrimitiveArray::from_iter(vec![70_000u32, 2]).into_array();
 
         let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable);
-        let trimmed = listview.rebuild(ListViewRebuildMode::TrimElements)?;
+        let mut ctx = SESSION.create_execution_ctx();
+        let trimmed = listview.rebuild(ListViewRebuildMode::TrimElements, &mut ctx)?;
         assert_arrays_eq!(
             trimmed.list_elements_at(1)?,
             PrimitiveArray::from_iter([30i32, 40])
@@ -655,7 +664,8 @@ mod tests {
         let sizes = PrimitiveArray::from_iter(vec![3i16, 2]).into_array();
 
         let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable);
-        let rebuilt = listview.rebuild(ListViewRebuildMode::MakeZeroCopyToList)?;
+        let mut ctx = SESSION.create_execution_ctx();
+        let rebuilt = listview.rebuild(ListViewRebuildMode::MakeZeroCopyToList, &mut ctx)?;
 
         // Values: [1,2,3] and [2,3].
         assert_arrays_eq!(
@@ -697,7 +707,8 @@ mod tests {
         let sizes = PrimitiveArray::from_iter(vec![46u8, 10]).into_array();
 
         let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable);
-        let trimmed = listview.rebuild(ListViewRebuildMode::TrimElements)?;
+        let mut ctx = SESSION.create_execution_ctx();
+        let trimmed = listview.rebuild(ListViewRebuildMode::TrimElements, &mut ctx)?;
 
         // min(offsets) = 0, so nothing to trim; output should equal input.
         assert_arrays_eq!(trimmed, listview);
diff --git a/vortex-array/src/arrays/listview/tests/common.rs b/vortex-array/src/arrays/listview/tests/common.rs
index dc8bc94fb18..be89b586209 100644
--- a/vortex-array/src/arrays/listview/tests/common.rs
+++ b/vortex-array/src/arrays/listview/tests/common.rs
@@ -3,14 +3,23 @@
 
 //! Common test utilities for ListView tests.
 
+use std::sync::LazyLock;
+
 use vortex_buffer::buffer;
+use vortex_session::VortexSession;
 
 use crate::IntoArray;
 use crate::arrays::BoolArray;
 use crate::arrays::ListViewArray;
 use crate::arrays::PrimitiveArray;
+use crate::session::ArraySession;
 use crate::validity::Validity;
 
+/// A shared session for `ListView` tests, used to create execution contexts via
+/// [`create_execution_ctx`](crate::VortexSessionExecute::create_execution_ctx).
+pub static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 /// Creates a basic ListView for testing: [[0,1,2], [3,4], [5,6], [7,8,9]]
 pub fn create_basic_listview() -> ListViewArray {
     let elements = buffer![0i32, 1, 2, 3, 4, 5, 6, 7, 8, 9].into_array();
diff --git a/vortex-array/src/arrays/listview/tests/operations.rs b/vortex-array/src/arrays/listview/tests/operations.rs
index 235caf53caa..c911b9ba7a5 100644
--- a/vortex-array/src/arrays/listview/tests/operations.rs
+++ b/vortex-array/src/arrays/listview/tests/operations.rs
@@ -5,11 +5,13 @@ use std::sync::Arc;
 
 use rstest::rstest;
 use vortex_buffer::buffer;
+use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
 use super::common::create_basic_listview;
 use super::common::create_large_listview;
 use super::common::create_nullable_listview;
+use crate::ArrayRef;
 use crate::IntoArray;
 use crate::LEGACY_SESSION;
 #[expect(deprecated)]
@@ -382,6 +384,100 @@ fn test_cast_large_dataset() {
     }
 }
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Zip tests
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#[test]
+fn test_zip_widens_false_element_nullability() -> VortexResult<()> {
+    // [[1, 2], [3], [4]]
+    let if_true = ListViewArray::new(
+        buffer![1i32, 2, 3, 4].into_array(),
+        buffer![0u32, 2, 3].into_array(),
+        buffer![2u32, 1, 1].into_array(),
+        Validity::NonNullable,
+    )
+    .into_array();
+    // [[10, null], [30], [40]]
+    let if_false = ListViewArray::new(
+        PrimitiveArray::from_option_iter([Some(10i32), None, Some(30), Some(40)]).into_array(),
+        buffer![0u32, 2, 3].into_array(),
+        buffer![2u32, 1, 1].into_array(),
+        Validity::NonNullable,
+    )
+    .into_array();
+    let mask = Mask::from_iter([false, true, false]);
+
+    let result = mask
+        .into_array()
+        .zip(if_true, if_false)?
+        .execute::<ArrayRef>(&mut LEGACY_SESSION.create_execution_ctx())?;
+    assert!(result.is::<ListView>());
+    assert_eq!(
+        result.dtype(),
+        &DType::List(
+            Arc::new(DType::Primitive(PType::I32, Nullability::Nullable)),
+            Nullability::NonNullable,
+        )
+    );
+
+    // [[10, null], [3], [40]]
+    let expected = ListViewArray::new(
+        PrimitiveArray::from_option_iter([Some(10i32), None, Some(3), Some(40)]).into_array(),
+        buffer![0u32, 2, 3].into_array(),
+        buffer![2u32, 1, 1].into_array(),
+        Validity::NonNullable,
+    )
+    .into_array();
+    assert_arrays_eq!(result, expected);
+    Ok(())
+}
+
+#[test]
+fn test_zip_widens_true_element_nullability() -> VortexResult<()> {
+    // [[1, null], [3], [4]]
+    let if_true = ListViewArray::new(
+        PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), Some(4)]).into_array(),
+        buffer![0u32, 2, 3].into_array(),
+        buffer![2u32, 1, 1].into_array(),
+        Validity::NonNullable,
+    )
+    .into_array();
+    // [[10], [20], [30]]
+    let if_false = ListViewArray::new(
+        buffer![10i32, 20, 30].into_array(),
+        buffer![0u32, 1, 2].into_array(),
+        buffer![1u32, 1, 1].into_array(),
+        Validity::NonNullable,
+    )
+    .into_array();
+    let mask = Mask::from_iter([true, false, true]);
+
+    let result = mask
+        .into_array()
+        .zip(if_true, if_false)?
+        .execute::<ArrayRef>(&mut LEGACY_SESSION.create_execution_ctx())?;
+    assert!(result.is::<ListView>());
+    assert_eq!(
+        result.dtype(),
+        &DType::List(
+            Arc::new(DType::Primitive(PType::I32, Nullability::Nullable)),
+            Nullability::NonNullable,
+        )
+    );
+
+    // [[1, null], [20], [4]]
+    let expected = ListViewArray::new(
+        PrimitiveArray::from_option_iter([Some(1i32), None, Some(20), Some(4)]).into_array(),
+        buffer![0u32, 2, 3].into_array(),
+        buffer![2u32, 1, 1].into_array(),
+        Validity::NonNullable,
+    )
+    .into_array();
+    assert_arrays_eq!(result, expected);
+    Ok(())
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Constant tests
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/vortex-array/src/arrays/listview/vtable/kernel.rs b/vortex-array/src/arrays/listview/vtable/kernel.rs
index f6ceca284bf..1ad98f62a33 100644
--- a/vortex-array/src/arrays/listview/vtable/kernel.rs
+++ b/vortex-array/src/arrays/listview/vtable/kernel.rs
@@ -4,6 +4,9 @@
 use crate::arrays::ListView;
 use crate::kernel::ParentKernelSet;
 use crate::scalar_fn::fns::cast::CastExecuteAdaptor;
+use crate::scalar_fn::fns::zip::ZipExecuteAdaptor;
 
-pub(super) const PARENT_KERNELS: ParentKernelSet<ListView> =
-    ParentKernelSet::new(&[ParentKernelSet::lift(&CastExecuteAdaptor(ListView))]);
+pub(super) const PARENT_KERNELS: ParentKernelSet<ListView> = ParentKernelSet::new(&[
+    ParentKernelSet::lift(&CastExecuteAdaptor(ListView)),
+    ParentKernelSet::lift(&ZipExecuteAdaptor(ListView)),
+]);
diff --git a/vortex-array/src/arrays/listview/vtable/mod.rs b/vortex-array/src/arrays/listview/vtable/mod.rs
index ddfa4aa0e6b..26e54b2d051 100644
--- a/vortex-array/src/arrays/listview/vtable/mod.rs
+++ b/vortex-array/src/arrays/listview/vtable/mod.rs
@@ -17,9 +17,9 @@ use vortex_session::registry::CachedId;
 use crate::ArrayEq;
 use crate::ArrayHash;
 use crate::ArrayRef;
+use crate::EqMode;
 use crate::ExecutionCtx;
 use crate::ExecutionResult;
-use crate::Precision;
 use crate::array::Array;
 use crate::array::ArrayId;
 use crate::array::ArrayView;
@@ -59,13 +59,13 @@ pub struct ListViewMetadata {
 }
 
 impl ArrayHash for ListViewData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _accuracy: EqMode) {
         self.is_zero_copy_to_list().hash(state);
     }
 }
 
 impl ArrayEq for ListViewData {
-    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, _accuracy: EqMode) -> bool {
         self.is_zero_copy_to_list() == other.is_zero_copy_to_list()
     }
 }
diff --git a/vortex-array/src/arrays/masked/tests.rs b/vortex-array/src/arrays/masked/tests.rs
index 2721ba9b519..b26d101eb33 100644
--- a/vortex-array/src/arrays/masked/tests.rs
+++ b/vortex-array/src/arrays/masked/tests.rs
@@ -134,7 +134,7 @@ fn test_masked_child_preserves_length(#[case] validity: Validity) {
         array
             .validity()
             .vortex_expect("masked validity should be derivable")
-            .mask_eq(&validity, &mut ctx)
+            .mask_eq(&validity, array.len(), &mut ctx)
             .unwrap(),
     );
 }
diff --git a/vortex-array/src/arrays/masked/vtable/mod.rs b/vortex-array/src/arrays/masked/vtable/mod.rs
index 257448c6eec..4409c8ff3c6 100644
--- a/vortex-array/src/arrays/masked/vtable/mod.rs
+++ b/vortex-array/src/arrays/masked/vtable/mod.rs
@@ -20,9 +20,9 @@ use crate::ArrayEq;
 use crate::ArrayHash;
 use crate::ArrayRef;
 use crate::Canonical;
+use crate::EqMode;
 use crate::IntoArray;
 use crate::LEGACY_SESSION;
-use crate::Precision;
 use crate::VortexSessionExecute;
 use crate::array::Array;
 use crate::array::ArrayId;
@@ -51,11 +51,11 @@ pub type MaskedArray = Array<Masked>;
 pub struct Masked;
 
 impl ArrayHash for MaskedData {
-    fn array_hash<H: Hasher>(&self, _state: &mut H, _precision: Precision) {}
+    fn array_hash<H: Hasher>(&self, _state: &mut H, _accuracy: EqMode) {}
 }
 
 impl ArrayEq for MaskedData {
-    fn array_eq(&self, _other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, _other: &Self, _accuracy: EqMode) -> bool {
         true
     }
 }
diff --git a/vortex-array/src/arrays/mod.rs b/vortex-array/src/arrays/mod.rs
index 212f4bbe619..148cf209555 100644
--- a/vortex-array/src/arrays/mod.rs
+++ b/vortex-array/src/arrays/mod.rs
@@ -50,6 +50,10 @@ pub mod fixed_size_list;
 pub use fixed_size_list::FixedSizeList;
 pub use fixed_size_list::FixedSizeListArray;
 
+pub mod interleave;
+pub use interleave::Interleave;
+pub use interleave::InterleaveArray;
+
 pub mod list;
 pub use list::List;
 pub use list::ListArray;
diff --git a/vortex-array/src/arrays/patched/compute/compare.rs b/vortex-array/src/arrays/patched/compute/compare.rs
index c7d879323cb..0f1e6add00f 100644
--- a/vortex-array/src/arrays/patched/compute/compare.rs
+++ b/vortex-array/src/arrays/patched/compute/compare.rs
@@ -55,9 +55,10 @@ impl CompareKernel for Patched {
 
         let validity = child_to_validity(result.slots()[0].as_ref(), result.dtype().nullability());
         let len = result.len();
-        let BoolDataParts { bits, offset, len } = result.into_data().into_parts(len);
+        let BoolDataParts { bits, meta } = result.into_data().into_parts(len);
 
-        let mut bits = BitBufferMut::from_buffer(bits.unwrap_host().into_mut(), offset, len);
+        let mut bits =
+            BitBufferMut::from_buffer(bits.unwrap_host().into_mut(), meta.offset(), meta.len());
 
         let lane_offsets = lhs.lane_offsets().clone().execute::<PrimitiveArray>(ctx)?;
         let indices = lhs.patch_indices().clone().execute::<PrimitiveArray>(ctx)?;
diff --git a/vortex-array/src/arrays/patched/vtable/mod.rs b/vortex-array/src/arrays/patched/vtable/mod.rs
index f35a13600c5..4ba5bc542e1 100644
--- a/vortex-array/src/arrays/patched/vtable/mod.rs
+++ b/vortex-array/src/arrays/patched/vtable/mod.rs
@@ -21,10 +21,10 @@ use vortex_session::registry::CachedId;
 
 use crate::ArrayRef;
 use crate::Canonical;
+use crate::EqMode;
 use crate::ExecutionCtx;
 use crate::ExecutionResult;
 use crate::IntoArray;
-use crate::Precision;
 use crate::array::Array;
 use crate::array::ArrayId;
 use crate::array::ArrayParts;
@@ -82,14 +82,14 @@ pub struct PatchedMetadata {
 }
 
 impl ArrayHash for PatchedData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _accuracy: EqMode) {
         self.offset.hash(state);
         self.n_lanes.hash(state);
     }
 }
 
 impl ArrayEq for PatchedData {
-    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, _accuracy: EqMode) -> bool {
         self.offset == other.offset && self.n_lanes == other.n_lanes
     }
 }
diff --git a/vortex-array/src/arrays/primitive/array/mod.rs b/vortex-array/src/arrays/primitive/array/mod.rs
index 7e3dd9b4ce7..e22fc9a4336 100644
--- a/vortex-array/src/arrays/primitive/array/mod.rs
+++ b/vortex-array/src/arrays/primitive/array/mod.rs
@@ -549,7 +549,7 @@ impl PrimitiveData {
             Validity::Array(is_valid) => {
                 #[expect(deprecated)]
                 let bool_array = is_valid.to_bool();
-                let bool_buffer = bool_array.to_bit_buffer();
+                let bool_buffer = bool_array.bit_buffer_view();
                 let mut bytes = ByteBufferMut::zeroed_aligned(n_rows * byte_width, alignment);
                 for (i, valid_i) in bool_buffer.set_indices().enumerate() {
                     bytes[valid_i * byte_width..(valid_i + 1) * byte_width]
diff --git a/vortex-array/src/arrays/primitive/compute/mod.rs b/vortex-array/src/arrays/primitive/compute/mod.rs
index 867ddf69d03..bd59efed20b 100644
--- a/vortex-array/src/arrays/primitive/compute/mod.rs
+++ b/vortex-array/src/arrays/primitive/compute/mod.rs
@@ -8,6 +8,7 @@ mod mask;
 pub(crate) mod rules;
 mod slice;
 mod take;
+mod zip;
 
 #[cfg(test)]
 mod tests {
diff --git a/vortex-array/src/arrays/primitive/compute/slice.rs b/vortex-array/src/arrays/primitive/compute/slice.rs
index 1830ef3f8c6..4775adba749 100644
--- a/vortex-array/src/arrays/primitive/compute/slice.rs
+++ b/vortex-array/src/arrays/primitive/compute/slice.rs
@@ -11,19 +11,21 @@ use crate::array::ArrayView;
 use crate::arrays::Primitive;
 use crate::arrays::PrimitiveArray;
 use crate::arrays::slice::SliceReduce;
-use crate::dtype::NativePType;
-use crate::match_each_native_ptype;
 
 impl SliceReduce for Primitive {
     fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
-        let result = match_each_native_ptype!(array.ptype(), |T| {
-            PrimitiveArray::from_buffer_handle(
-                array.buffer_handle().slice_typed::<T>(range.clone()),
-                T::PTYPE,
-                array.validity()?.slice(range)?,
-            )
-            .into_array()
-        });
-        Ok(Some(result))
+        let byte_width = array.ptype().byte_width();
+        let byte_range = range.start * byte_width..range.end * byte_width;
+        let values = array.buffer_handle().slice(byte_range);
+        let validity = array.validity()?.slice(range)?;
+
+        // SAFETY:
+        //slicing an existing PrimitiveArray on element boundaries preserves the buffer
+        // alignment, ptype, length, and validity invariants.
+        let array = unsafe {
+            PrimitiveArray::new_unchecked_from_handle(values, array.ptype(), validity).into_array()
+        };
+
+        Ok(Some(array))
     }
 }
diff --git a/vortex-array/src/arrays/primitive/compute/zip.rs b/vortex-array/src/arrays/primitive/compute/zip.rs
new file mode 100644
index 00000000000..0dcb7298460
--- /dev/null
+++ b/vortex-array/src/arrays/primitive/compute/zip.rs
@@ -0,0 +1,223 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::mem::MaybeUninit;
+
+use vortex_buffer::BufferMut;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_mask::Mask;
+
+use crate::ArrayRef;
+use crate::ExecutionCtx;
+use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::arrays::Primitive;
+use crate::arrays::PrimitiveArray;
+use crate::dtype::NativePType;
+use crate::match_each_native_ptype;
+use crate::scalar_fn::fns::zip::ZipKernel;
+use crate::scalar_fn::fns::zip::zip_validity;
+
+/// A dedicated primitive zip kernel that selects values branchlessly per row.
+///
+/// The generic zip path copies runs of `if_true`/`if_false` between mask boundaries, which is fast
+/// for clustered masks but degrades to per-element work on fragmented masks. This kernel instead
+/// walks the mask as 64-bit chunks and blends both sides per row without a data-dependent branch,
+/// so the inner loop stays branch-free and auto-vectorizable regardless of mask shape.
+impl ZipKernel for Primitive {
+    fn zip(
+        if_true: ArrayView<'_, Primitive>,
+        if_false: &ArrayRef,
+        mask: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        let Some(if_false) = if_false.as_opt::<Primitive>() else {
+            return Ok(None);
+        };
+
+        if if_true.ptype() != if_false.ptype() {
+            vortex_bail!(
+                "zip requires if_true and if_false to share a primitive type, got {} and {}",
+                if_true.ptype(),
+                if_false.ptype()
+            );
+        }
+
+        // Null mask entries select `if_false`, matching `Zip`'s SQL ELSE semantics.
+        let mask = mask.try_to_mask_fill_null_false(ctx)?;
+        match &mask {
+            // Defer trivial masks to the generic zip, which just casts the surviving side.
+            Mask::AllTrue(_) | Mask::AllFalse(_) => return Ok(None),
+            Mask::Values(_) => {}
+        }
+
+        let validity = zip_validity(if_true.validity()?, if_false.validity()?, &mask)?;
+
+        // TODO(perf): inspect the mask's true_count (and validity) to special-case heavily-skewed
+        // masks. When one side dominates (true_count near 0 or near len), it is cheaper to bulk
+        // copy — or mutate in place, if the dominant side is uniquely owned — that side's values
+        // and validity, then conditionally pull in only the minority rows from the other side,
+        // rather than blending every row.
+        let array = match_each_native_ptype!(if_true.ptype(), |T| {
+            let values =
+                select_values::<T>(if_true.as_slice::<T>(), if_false.as_slice::<T>(), &mask);
+            PrimitiveArray::new(values.freeze(), validity).into_array()
+        });
+        Ok(Some(array))
+    }
+}
+
+/// Branchlessly blend `if_true` and `if_false` per row into a fresh value buffer.
+fn select_values<T: NativePType>(
+    true_values: &[T],
+    false_values: &[T],
+    mask: &Mask,
+) -> BufferMut<T> {
+    let len = true_values.len();
+    let mut out = BufferMut::<T>::with_capacity(len);
+    {
+        let out_slice = out.spare_capacity_mut();
+
+        let mask_bits = mask
+            .values()
+            .vortex_expect("mask is Mask::Values")
+            .bit_buffer();
+        // TODO(perf): `unaligned_chunks` is a faster single-buffer iterator than `chunks`; switch to
+        // it here, handling its lead/trailing padding.
+        let chunks = mask_bits.chunks();
+
+        let mut base = 0;
+        for word in chunks.iter() {
+            let end = base + 64;
+            select_block(
+                word,
+                &true_values[base..end],
+                &false_values[base..end],
+                &mut out_slice[base..end],
+            );
+            base = end;
+        }
+
+        let remainder = chunks.remainder_len();
+        if remainder > 0 {
+            let end = base + remainder;
+            select_block(
+                chunks.remainder_bits(),
+                &true_values[base..end],
+                &false_values[base..end],
+                &mut out_slice[base..end],
+            );
+        }
+    }
+
+    // SAFETY: `select_block` initialized every slot covered by the chunks plus remainder, i.e. `len`.
+    unsafe { out.set_len(len) };
+    out
+}
+
+/// Blend one 64-bit mask chunk's worth of rows: bit `j` (LSB-first) keeps `true_values[j]`, an unset
+/// bit keeps `false_values[j]`. Slices are trimmed to the output length up front so the compiler can
+/// elide bounds checks and lower the body to a vector blend / conditional move.
+#[inline]
+fn select_block<T: NativePType>(
+    word: u64,
+    true_values: &[T],
+    false_values: &[T],
+    out: &mut [MaybeUninit<T>],
+) {
+    let n = out.len();
+    let true_values = &true_values[..n];
+    let false_values = &false_values[..n];
+    for j in 0..n {
+        let pick = (word >> j) & 1 == 1;
+        out[j].write(if pick {
+            true_values[j]
+        } else {
+            false_values[j]
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #![allow(
+        clippy::cast_possible_truncation,
+        reason = "test fixtures use small indices that fit the target widths"
+    )]
+
+    use vortex_error::VortexResult;
+    use vortex_mask::Mask;
+
+    use crate::ArrayRef;
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::arrays::Primitive;
+    use crate::arrays::PrimitiveArray;
+    use crate::assert_arrays_eq;
+    use crate::builtins::ArrayBuiltins;
+
+    /// The branchless kernel must agree with the scalar reference across the chunk boundary (index
+    /// 63/64) and the trailing remainder, for non-nullable inputs.
+    #[test]
+    fn zip_nonnull_spans_mask_chunks() -> VortexResult<()> {
+        let len = 150usize;
+        let if_true = PrimitiveArray::from_iter(0..len as i64).into_array();
+        let if_false = PrimitiveArray::from_iter((0..len as i64).map(|i| 1_000 + i)).into_array();
+
+        let bits: Vec<bool> = (0..len).map(|i| i.is_multiple_of(3) || i == 64).collect();
+        let mask = Mask::from_iter(bits.iter().copied());
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let result = mask
+            .into_array()
+            .zip(if_true, if_false)?
+            .execute::<ArrayRef>(&mut ctx)?;
+        assert!(result.is::<Primitive>());
+
+        let expected = PrimitiveArray::from_iter(
+            (0..len).map(|i| if bits[i] { i as i64 } else { 1_000 + i as i64 }),
+        )
+        .into_array();
+        assert_arrays_eq!(result, expected);
+        Ok(())
+    }
+
+    /// With `Validity::Array` on both sides the kernel must select values and validity from the
+    /// chosen side across the chunk boundary.
+    #[test]
+    fn zip_nullable_selects_values_and_validity() -> VortexResult<()> {
+        let len = 130usize;
+        let if_true =
+            PrimitiveArray::from_option_iter((0..len as i64).map(|i| (i % 4 != 0).then_some(i)))
+                .into_array();
+        let if_false = PrimitiveArray::from_option_iter(
+            (0..len as i64).map(|i| (i % 5 != 0).then_some(1_000 + i)),
+        )
+        .into_array();
+
+        let bits: Vec<bool> = (0..len).map(|i| i.is_multiple_of(2)).collect();
+        let mask = Mask::from_iter(bits.iter().copied());
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let result = mask
+            .into_array()
+            .zip(if_true, if_false)?
+            .execute::<ArrayRef>(&mut ctx)?;
+        assert!(result.is::<Primitive>());
+
+        let expected = PrimitiveArray::from_option_iter((0..len).map(|i| {
+            let v = i as i64;
+            if bits[i] {
+                (!i.is_multiple_of(4)).then_some(v)
+            } else {
+                (!i.is_multiple_of(5)).then_some(1_000 + v)
+            }
+        }))
+        .into_array();
+        assert_arrays_eq!(result, expected);
+        Ok(())
+    }
+}
diff --git a/vortex-array/src/arrays/primitive/vtable/kernel.rs b/vortex-array/src/arrays/primitive/vtable/kernel.rs
index 03b6cfa2b98..341d2f21272 100644
--- a/vortex-array/src/arrays/primitive/vtable/kernel.rs
+++ b/vortex-array/src/arrays/primitive/vtable/kernel.rs
@@ -7,10 +7,12 @@ use crate::kernel::ParentKernelSet;
 use crate::scalar_fn::fns::between::BetweenExecuteAdaptor;
 use crate::scalar_fn::fns::cast::CastExecuteAdaptor;
 use crate::scalar_fn::fns::fill_null::FillNullExecuteAdaptor;
+use crate::scalar_fn::fns::zip::ZipExecuteAdaptor;
 
 pub(super) const PARENT_KERNELS: ParentKernelSet<Primitive> = ParentKernelSet::new(&[
     ParentKernelSet::lift(&BetweenExecuteAdaptor(Primitive)),
     ParentKernelSet::lift(&CastExecuteAdaptor(Primitive)),
     ParentKernelSet::lift(&FillNullExecuteAdaptor(Primitive)),
     ParentKernelSet::lift(&TakeExecuteAdaptor(Primitive)),
+    ParentKernelSet::lift(&ZipExecuteAdaptor(Primitive)),
 ]);
diff --git a/vortex-array/src/arrays/primitive/vtable/mod.rs b/vortex-array/src/arrays/primitive/vtable/mod.rs
index 5130665cd30..4b472d122f3 100644
--- a/vortex-array/src/arrays/primitive/vtable/mod.rs
+++ b/vortex-array/src/arrays/primitive/vtable/mod.rs
@@ -29,7 +29,7 @@ use vortex_buffer::Alignment;
 use vortex_session::VortexSession;
 use vortex_session::registry::CachedId;
 
-use crate::Precision;
+use crate::EqMode;
 use crate::array::ArrayId;
 use crate::arrays::primitive::array::SLOT_NAMES;
 use crate::arrays::primitive::compute::rules::RULES;
@@ -40,14 +40,14 @@ use crate::hash::ArrayHash;
 pub type PrimitiveArray = Array<Primitive>;
 
 impl ArrayHash for PrimitiveData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
-        self.buffer.array_hash(state, precision);
+    fn array_hash<H: Hasher>(&self, state: &mut H, accuracy: EqMode) {
+        self.buffer.array_hash(state, accuracy);
     }
 }
 
 impl ArrayEq for PrimitiveData {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
-        self.buffer.array_eq(&other.buffer, precision)
+    fn array_eq(&self, other: &Self, accuracy: EqMode) -> bool {
+        self.buffer.array_eq(&other.buffer, accuracy)
     }
 }
 
diff --git a/vortex-array/src/arrays/scalar_fn/array.rs b/vortex-array/src/arrays/scalar_fn/array.rs
index 2c77be3c329..a999a25cd51 100644
--- a/vortex-array/src/arrays/scalar_fn/array.rs
+++ b/vortex-array/src/arrays/scalar_fn/array.rs
@@ -6,6 +6,7 @@ use std::fmt::Formatter;
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 
 use crate::ArrayRef;
@@ -30,19 +31,6 @@ impl Display for ScalarFnData {
 }
 
 impl ScalarFnData {
-    /// Create a new ScalarFnArray from a scalar function and its children.
-    pub fn build(
-        scalar_fn: ScalarFnRef,
-        children: Vec<ArrayRef>,
-        len: usize,
-    ) -> VortexResult<Self> {
-        vortex_ensure!(
-            children.iter().all(|c| c.len() == len),
-            "ScalarFnArray must have children equal to the array length"
-        );
-        Ok(Self { scalar_fn })
-    }
-
     /// Get the scalar function bound to this array.
     #[inline(always)]
     pub fn scalar_fn(&self) -> &ScalarFnRef {
@@ -85,14 +73,26 @@ impl<T: TypedArrayRef<ScalarFn>> ScalarFnArrayExt for T {}
 
 impl Array<ScalarFn> {
     /// Create a new ScalarFnArray from a scalar function and its children.
-    pub fn try_new(
+    pub fn try_new(scalar_fn: ScalarFnRef, children: Vec<ArrayRef>) -> VortexResult<Self> {
+        let len = Self::infer_len(&children)?;
+        Self::try_new_with_len(scalar_fn, children, len)
+    }
+
+    /// Create a new ScalarFnArray from a scalar function, children, and an explicit length.
+    ///
+    /// This is needed for zero-child scalar functions and deserialization paths where there is no
+    /// child array to infer the length from.
+    pub fn try_new_with_len(
         scalar_fn: ScalarFnRef,
         children: Vec<ArrayRef>,
         len: usize,
     ) -> VortexResult<Self> {
+        Self::validate_children_len(&children, len)?;
         let arg_dtypes: Vec<_> = children.iter().map(|c| c.dtype().clone()).collect();
         let dtype = scalar_fn.return_dtype(&arg_dtypes)?;
-        let data = ScalarFnData::build(scalar_fn.clone(), children.clone(), len)?;
+        let data = ScalarFnData {
+            scalar_fn: scalar_fn.clone(),
+        };
         let vtable = ScalarFn { id: scalar_fn.id() };
         Ok(unsafe {
             Array::from_parts_unchecked(
@@ -101,4 +101,19 @@ impl Array<ScalarFn> {
             )
         })
     }
+
+    fn infer_len(children: &[ArrayRef]) -> VortexResult<usize> {
+        let Some(child) = children.first() else {
+            vortex_bail!("ScalarFnArray length cannot be inferred without children");
+        };
+        Ok(child.len())
+    }
+
+    fn validate_children_len(children: &[ArrayRef], len: usize) -> VortexResult<()> {
+        vortex_ensure!(
+            children.iter().all(|c| c.len() == len),
+            "ScalarFnArray must have children equal to the array length"
+        );
+        Ok(())
+    }
 }
diff --git a/vortex-array/src/arrays/scalar_fn/plugin.rs b/vortex-array/src/arrays/scalar_fn/plugin.rs
index c685503a370..044f79362cd 100644
--- a/vortex-array/src/arrays/scalar_fn/plugin.rs
+++ b/vortex-array/src/arrays/scalar_fn/plugin.rs
@@ -82,7 +82,7 @@ impl<V: ScalarFnVTable + ScalarFnArrayVTable> ArrayPlugin for ScalarFnArrayPlugi
         let parts = <V as ScalarFnArrayVTable>::deserialize(
             &self.0, dtype, len, metadata, children, session,
         )?;
-        Ok(ScalarFnArray::try_new(
+        Ok(ScalarFnArray::try_new_with_len(
             TypedScalarFnInstance::new(self.0.clone(), parts.options).erased(),
             parts.children,
             len,
diff --git a/vortex-array/src/arrays/scalar_fn/rules.rs b/vortex-array/src/arrays/scalar_fn/rules.rs
index 1e9563cf9de..abc8e18e762 100644
--- a/vortex-array/src/arrays/scalar_fn/rules.rs
+++ b/vortex-array/src/arrays/scalar_fn/rules.rs
@@ -84,7 +84,8 @@ impl ArrayParentReduceRule<ScalarFn> for ScalarFnSliceReduceRule {
             .collect::<VortexResult<_>>()?;
 
         Ok(Some(
-            ScalarFnArray::try_new(array.scalar_fn().clone(), children, range.len())?.into_array(),
+            ScalarFnArray::try_new_with_len(array.scalar_fn().clone(), children, range.len())?
+                .into_array(),
         ))
     }
 }
@@ -142,7 +143,7 @@ impl ReduceCtx for ArrayReduceCtx {
         children: &[ReduceNodeRef],
     ) -> VortexResult<ReduceNodeRef> {
         Ok(Arc::new(
-            ScalarFnArray::try_new(
+            ScalarFnArray::try_new_with_len(
                 scalar_fn,
                 children
                     .iter()
@@ -191,8 +192,7 @@ impl ArrayParentReduceRule<ScalarFn> for ScalarFnUnaryFilterPushDownRule {
                 .try_collect()?;
 
             let new_array =
-                ScalarFnArray::try_new(child.scalar_fn().clone(), new_children, parent.len())?
-                    .into_array();
+                ScalarFnArray::try_new(child.scalar_fn().clone(), new_children)?.into_array();
 
             return Ok(Some(new_array));
         }
diff --git a/vortex-array/src/arrays/scalar_fn/vtable/mod.rs b/vortex-array/src/arrays/scalar_fn/vtable/mod.rs
index 5906b3372f4..6833848deae 100644
--- a/vortex-array/src/arrays/scalar_fn/vtable/mod.rs
+++ b/vortex-array/src/arrays/scalar_fn/vtable/mod.rs
@@ -21,8 +21,8 @@ use crate::ArrayEq;
 use crate::ArrayHash;
 use crate::ArrayRef;
 use crate::ArraySlots;
+use crate::EqMode;
 use crate::IntoArray;
-use crate::Precision;
 use crate::array::Array;
 use crate::array::ArrayId;
 use crate::array::ArrayParts;
@@ -56,13 +56,13 @@ pub struct ScalarFn {
 }
 
 impl ArrayHash for ScalarFnData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _accuracy: EqMode) {
         self.scalar_fn().hash(state);
     }
 }
 
 impl ArrayEq for ScalarFnData {
-    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, _accuracy: EqMode) -> bool {
         self.scalar_fn() == other.scalar_fn()
     }
 }
diff --git a/vortex-array/src/arrays/scalar_fn/vtable/operations.rs b/vortex-array/src/arrays/scalar_fn/vtable/operations.rs
index 1f710af3cdf..67de19d936f 100644
--- a/vortex-array/src/arrays/scalar_fn/vtable/operations.rs
+++ b/vortex-array/src/arrays/scalar_fn/vtable/operations.rs
@@ -65,9 +65,12 @@ mod tests {
     use crate::arrays::BoolArray;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::ScalarFnArray;
+    use crate::arrays::scalar_fn::ScalarFnArrayExt;
     use crate::assert_arrays_eq;
+    use crate::scalar::Scalar;
     use crate::scalar_fn::TypedScalarFnInstance;
     use crate::scalar_fn::fns::binary::Binary;
+    use crate::scalar_fn::fns::literal::Literal;
     use crate::scalar_fn::fns::operators::Operator;
     use crate::validity::Validity;
 
@@ -77,7 +80,9 @@ mod tests {
         let rhs = buffer![10i32, 20, 30].into_array();
 
         let scalar_fn = TypedScalarFnInstance::new(Binary, Operator::Add).erased();
-        let scalar_fn_array = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs], 3)?;
+        let scalar_fn_array = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])?;
+
+        assert_eq!(scalar_fn_array.len(), 3);
 
         let result = scalar_fn_array
             .into_array()
@@ -89,13 +94,47 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn test_scalar_fn_inferred_len_rejects_mismatched_children() {
+        let lhs = buffer![1i32, 2, 3].into_array();
+        let rhs = buffer![10i32, 20].into_array();
+
+        let scalar_fn = TypedScalarFnInstance::new(Binary, Operator::Add).erased();
+        let err = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])
+            .expect_err("ScalarFnArray::try_new must reject mismatched child lengths");
+
+        assert!(
+            err.to_string()
+                .contains("ScalarFnArray must have children equal to the array length")
+        );
+    }
+
+    #[test]
+    fn test_scalar_fn_without_children_requires_explicit_len() -> VortexResult<()> {
+        let scalar_fn = TypedScalarFnInstance::new(Literal, Scalar::from(1i32)).erased();
+
+        let Err(err) = ScalarFnArray::try_new(scalar_fn.clone(), vec![]) else {
+            panic!("ScalarFnArray::try_new should reject zero children");
+        };
+        assert!(
+            err.to_string()
+                .contains("ScalarFnArray length cannot be inferred without children")
+        );
+
+        let scalar_fn_array = ScalarFnArray::try_new_with_len(scalar_fn, vec![], 3)?;
+        assert_eq!(scalar_fn_array.len(), 3);
+        assert_eq!(scalar_fn_array.child_count(), 0);
+
+        Ok(())
+    }
+
     #[test]
     fn test_scalar_fn_mul() -> VortexResult<()> {
         let lhs = buffer![2i32, 3, 4].into_array();
         let rhs = buffer![5i32, 6, 7].into_array();
 
         let scalar_fn = TypedScalarFnInstance::new(Binary, Operator::Mul).erased();
-        let scalar_fn_array = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs], 3)?;
+        let scalar_fn_array = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])?;
 
         let result = scalar_fn_array
             .into_array()
@@ -117,7 +156,7 @@ mod tests {
         .into_array();
 
         let scalar_fn = TypedScalarFnInstance::new(Binary, Operator::Add).erased();
-        let scalar_fn_array = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs], 3)?;
+        let scalar_fn_array = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])?;
 
         let result = scalar_fn_array
             .into_array()
@@ -139,7 +178,7 @@ mod tests {
         let rhs = buffer![2i32, 5, 1].into_array();
 
         let scalar_fn = TypedScalarFnInstance::new(Binary, Operator::Eq).erased();
-        let scalar_fn_array = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs], 3)?;
+        let scalar_fn_array = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])?;
 
         let result = scalar_fn_array
             .into_array()
diff --git a/vortex-array/src/arrays/shared/tests.rs b/vortex-array/src/arrays/shared/tests.rs
index 359a0919965..b8301389074 100644
--- a/vortex-array/src/arrays/shared/tests.rs
+++ b/vortex-array/src/arrays/shared/tests.rs
@@ -12,7 +12,7 @@ use crate::arrays::PrimitiveArray;
 use crate::arrays::SharedArray;
 use crate::arrays::shared::SharedArrayExt;
 use crate::hash::ArrayEq;
-use crate::hash::Precision as HashPrecision;
+use crate::hash::EqMode;
 use crate::session::ArraySession;
 use crate::validity::Validity;
 
@@ -29,7 +29,7 @@ fn shared_array_caches_on_canonicalize() -> VortexResult<()> {
     // Second call should return cached without invoking the closure.
     let second = shared.get_or_compute(|_| panic!("should not execute twice"))?;
 
-    assert!(first.array_eq(&second, HashPrecision::Value));
+    assert!(first.array_eq(&second, EqMode::Value));
 
     Ok(())
 }
diff --git a/vortex-array/src/arrays/shared/vtable.rs b/vortex-array/src/arrays/shared/vtable.rs
index f13a262479e..3c3a09216d2 100644
--- a/vortex-array/src/arrays/shared/vtable.rs
+++ b/vortex-array/src/arrays/shared/vtable.rs
@@ -13,9 +13,9 @@ use crate::ArrayEq;
 use crate::ArrayHash;
 use crate::ArrayRef;
 use crate::Canonical;
+use crate::EqMode;
 use crate::ExecutionCtx;
 use crate::ExecutionResult;
-use crate::Precision;
 use crate::array::Array;
 use crate::array::ArrayId;
 use crate::array::ArrayView;
@@ -39,11 +39,11 @@ pub type SharedArray = Array<Shared>;
 pub struct Shared;
 
 impl ArrayHash for SharedData {
-    fn array_hash<H: Hasher>(&self, _state: &mut H, _precision: Precision) {}
+    fn array_hash<H: Hasher>(&self, _state: &mut H, _accuracy: EqMode) {}
 }
 
 impl ArrayEq for SharedData {
-    fn array_eq(&self, _other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, _other: &Self, _accuracy: EqMode) -> bool {
         true
     }
 }
diff --git a/vortex-array/src/arrays/slice/vtable.rs b/vortex-array/src/arrays/slice/vtable.rs
index ac0ecc18039..1ca91254123 100644
--- a/vortex-array/src/arrays/slice/vtable.rs
+++ b/vortex-array/src/arrays/slice/vtable.rs
@@ -19,7 +19,7 @@ use crate::AnyCanonical;
 use crate::ArrayEq;
 use crate::ArrayHash;
 use crate::ArrayRef;
-use crate::Precision;
+use crate::EqMode;
 use crate::array::Array;
 use crate::array::ArrayId;
 use crate::array::ArrayView;
@@ -47,14 +47,14 @@ pub type SliceArray = Array<Slice>;
 pub struct Slice;
 
 impl ArrayHash for SliceData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, _precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, _accuracy: EqMode) {
         self.range.start.hash(state);
         self.range.end.hash(state);
     }
 }
 
 impl ArrayEq for SliceData {
-    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, _accuracy: EqMode) -> bool {
         self.range == other.range
     }
 }
diff --git a/vortex-array/src/arrays/varbin/array.rs b/vortex-array/src/arrays/varbin/array.rs
index deaef952d5e..4d435471ce0 100644
--- a/vortex-array/src/arrays/varbin/array.rs
+++ b/vortex-array/src/arrays/varbin/array.rs
@@ -6,6 +6,7 @@ use std::fmt::Formatter;
 
 use num_traits::AsPrimitive;
 use smallvec::smallvec;
+use vortex_array::arrays::PrimitiveArray;
 use vortex_buffer::ByteBuffer;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
@@ -15,8 +16,6 @@ use vortex_error::vortex_err;
 use crate::ArrayRef;
 use crate::ArraySlots;
 use crate::LEGACY_SESSION;
-#[expect(deprecated)]
-use crate::ToCanonical as _;
 use crate::VortexSessionExecute;
 use crate::array::Array;
 use crate::array::ArrayParts;
@@ -208,26 +207,6 @@ impl VarBinData {
             InvalidArgument: "Offsets must have at least one element"
         );
 
-        // Skip host-only validation when offsets/bytes are not host-resident.
-        if offsets.is_host() && bytes.is_on_host() {
-            let last_offset = offsets
-                .execute_scalar(
-                    offsets.len() - 1,
-                    &mut LEGACY_SESSION.create_execution_ctx(),
-                )?
-                .as_primitive()
-                .as_::<usize>()
-                .ok_or_else(
-                    || vortex_err!(InvalidArgument: "Last offset must be convertible to usize"),
-                )?;
-            vortex_ensure!(
-                last_offset <= bytes.len(),
-                InvalidArgument: "Last offset {} exceeds bytes length {}",
-                last_offset,
-                bytes.len()
-            );
-        }
-
         // Check validity length
         if let Some(validity_len) = validity.maybe_len() {
             vortex_ensure!(
@@ -244,33 +223,65 @@ impl VarBinData {
             && matches!(dtype, DType::Utf8(_))
             && let Some(bytes) = bytes.as_host_opt()
         {
-            #[expect(deprecated)]
-            let primitive_offsets = offsets.to_primitive();
-            match_each_integer_ptype!(primitive_offsets.dtype().as_ptype(), |O| {
-                let offsets_slice = primitive_offsets.as_slice::<O>();
-                for (i, (start, end)) in offsets_slice
-                    .windows(2)
-                    .map(|o| (o[0].as_(), o[1].as_()))
-                    .enumerate()
-                {
-                    if validity.is_null(i)? {
-                        continue;
-                    }
-
-                    let string_bytes = &bytes.as_ref()[start..end];
-                    simdutf8::basic::from_utf8(string_bytes).map_err(|_| {
-                        #[expect(clippy::unwrap_used)]
-                        // run validation using `compat` package to get more detailed error message
-                        let err = simdutf8::compat::from_utf8(string_bytes).unwrap_err();
-                        vortex_err!("invalid utf-8: {err} at index {i}")
-                    })?;
-                }
-            });
+            Self::validate_utf8(offsets, bytes.as_ref(), validity)?;
         }
 
         Ok(())
     }
 
+    /// Validates that every non-null value is valid UTF-8.
+    fn validate_utf8(offsets: &ArrayRef, bytes: &[u8], validity: &Validity) -> VortexResult<()> {
+        let validate_at = |i: usize, start: usize, end: usize| -> VortexResult<()> {
+            let string_bytes = &bytes[start..end];
+            simdutf8::basic::from_utf8(string_bytes).map_err(|_| {
+                #[expect(clippy::unwrap_used)]
+                // run validation using `compat` package to get more detailed error message
+                let err = simdutf8::compat::from_utf8(string_bytes).unwrap_err();
+                vortex_err!("invalid utf-8: {err} at index {i}")
+            })?;
+            Ok(())
+        };
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        // TODO(joe): update the created VarBin with this decompressed Array.
+        let primitive_offsets = offsets.clone().execute::<PrimitiveArray>(&mut ctx)?;
+
+        // Array-backed validity is the only variant that needs an execution context: execute it into
+        // a mask once. The constant variants resolve null-ness without one. Resolving this before
+        // the per-type dispatch keeps the dtype loop simple.
+        let mask = match validity {
+            Validity::Array(_) => {
+                Some(validity.execute_mask(primitive_offsets.len().saturating_sub(1), &mut ctx)?)
+            }
+            _ => None,
+        };
+        let all_invalid = matches!(validity, Validity::AllInvalid);
+
+        match_each_integer_ptype!(primitive_offsets.dtype().as_ptype(), |O| {
+            let offsets_slice = primitive_offsets.as_slice::<O>();
+
+            let last_offset: usize = offsets_slice[offsets_slice.len() - 1].as_();
+            vortex_ensure!(
+                last_offset <= bytes.len(),
+                InvalidArgument: "Last offset {} exceeds bytes length {}",
+                last_offset,
+                bytes.len()
+            );
+
+            for (i, (start, end)) in offsets_slice
+                .windows(2)
+                .map(|o| (o[0].as_(), o[1].as_()))
+                .enumerate()
+            {
+                let valid = mask.as_ref().map_or(!all_invalid, |mask| mask.value(i));
+                if valid {
+                    validate_at(i, start, end)?;
+                }
+            }
+        });
+        Ok(())
+    }
+
     /// Access the value bytes child buffer
     ///
     /// # Note
diff --git a/vortex-array/src/arrays/varbin/compute/compare.rs b/vortex-array/src/arrays/varbin/compute/compare.rs
index 37ec64e0802..9a5a615c81e 100644
--- a/vortex-array/src/arrays/varbin/compute/compare.rs
+++ b/vortex-array/src/arrays/varbin/compute/compare.rs
@@ -23,7 +23,7 @@ use crate::arrays::VarBin;
 use crate::arrays::VarBinViewArray;
 use crate::arrays::varbin::VarBinArrayExt;
 use crate::arrow::Datum;
-use crate::arrow::from_arrow_array_with_len;
+use crate::arrow::from_arrow_columnar;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::dtype::IntegerPType;
@@ -125,7 +125,7 @@ impl CompareKernel for VarBin {
             }
             .map_err(|err| vortex_err!("Failed to compare VarBin array: {}", err))?;
 
-            Ok(Some(from_arrow_array_with_len(&array, len, nullable)?))
+            Ok(Some(from_arrow_columnar(&array, len, nullable, ctx)?))
         } else if !rhs.is::<VarBin>() {
             // NOTE: If the rhs is not a VarBin array it will be canonicalized to a VarBinView
             // Arrow doesn't support comparing VarBin to VarBinView arrays, so we convert ourselves
diff --git a/vortex-array/src/arrays/varbin/compute/filter.rs b/vortex-array/src/arrays/varbin/compute/filter.rs
index b3e1aa87a4f..a0c78a64363 100644
--- a/vortex-array/src/arrays/varbin/compute/filter.rs
+++ b/vortex-array/src/arrays/varbin/compute/filter.rs
@@ -24,7 +24,6 @@ use crate::arrays::varbin::builder::VarBinBuilder;
 use crate::dtype::DType;
 use crate::dtype::IntegerPType;
 use crate::match_each_integer_ptype;
-use crate::validity::Validity;
 
 impl FilterKernel for VarBin {
     fn filter(
@@ -170,7 +169,10 @@ fn filter_select_var_bin_by_index(
             offsets.as_slice::<O>(),
             values.bytes().as_slice(),
             mask_indices,
-            values.validity()?,
+            values
+                .varbin_validity()
+                .execute_mask(values.as_ref().len(), ctx)
+                .vortex_expect("Failed to compute validity mask"),
             selection_count,
         )
     })
@@ -181,24 +183,37 @@ fn filter_select_var_bin_by_index_primitive_offset<O: IntegerPType>(
     offsets: &[O],
     data: &[u8],
     mask_indices: &[usize],
-    // TODO(ngates): pass LogicalValidity instead
-    validity: Validity,
+    mask: Mask,
     selection_count: usize,
 ) -> VortexResult<VarBinArray> {
+    let value_at = |idx: usize| -> VortexResult<&[u8]> {
+        let start = offsets[idx]
+            .to_usize()
+            .ok_or_else(|| vortex_err!("Failed to convert offset to usize: {}", offsets[idx]))?;
+        let end = offsets[idx + 1].to_usize().ok_or_else(|| {
+            vortex_err!("Failed to convert offset to usize: {}", offsets[idx + 1])
+        })?;
+        Ok(&data[start..end])
+    };
+
     let mut builder = VarBinBuilder::<O>::with_capacity(selection_count);
-    for idx in mask_indices.iter().copied() {
-        if validity.is_valid(idx)? {
-            let (start, end) = (
-                offsets[idx].to_usize().ok_or_else(|| {
-                    vortex_err!("Failed to convert offset to usize: {}", offsets[idx])
-                })?,
-                offsets[idx + 1].to_usize().ok_or_else(|| {
-                    vortex_err!("Failed to convert offset to usize: {}", offsets[idx + 1])
-                })?,
-            );
-            builder.append_value(&data[start..end])
-        } else {
-            builder.append_null()
+    match mask.bit_buffer() {
+        AllOr::All => {
+            for idx in mask_indices.iter().copied() {
+                builder.append_value(value_at(idx)?)
+            }
+        }
+        AllOr::None => {
+            builder.append_n_nulls(selection_count);
+        }
+        AllOr::Some(validity) => {
+            for idx in mask_indices.iter().copied() {
+                if validity.value(idx) {
+                    builder.append_value(value_at(idx)?)
+                } else {
+                    builder.append_null()
+                }
+            }
         }
     }
     Ok(builder.finish(dtype))
diff --git a/vortex-array/src/arrays/varbin/compute/take.rs b/vortex-array/src/arrays/varbin/compute/take.rs
index cb4b4031cd4..5826633aea3 100644
--- a/vortex-array/src/arrays/varbin/compute/take.rs
+++ b/vortex-array/src/arrays/varbin/compute/take.rs
@@ -202,8 +202,8 @@ fn take_nullable<Index: IntegerPType, Offset: IntegerPType, NewOffset: IntegerPT
     let mut valid_indices = Vec::with_capacity(indices.len());
 
     // First pass: calculate offsets and validity
-    for (idx, data_idx) in indices.iter().enumerate() {
-        if !indices_validity.value(idx) {
+    for (data_idx, index_valid) in indices.iter().zip(indices_validity.iter()) {
+        if !index_valid {
             validity_buffer.append(false);
             new_offsets.push(current_offset);
             continue;
diff --git a/vortex-array/src/arrays/varbin/vtable/mod.rs b/vortex-array/src/arrays/varbin/vtable/mod.rs
index c1a0941e720..dae80b663de 100644
--- a/vortex-array/src/arrays/varbin/vtable/mod.rs
+++ b/vortex-array/src/arrays/varbin/vtable/mod.rs
@@ -39,7 +39,7 @@ use canonical::varbin_to_canonical;
 use kernel::PARENT_KERNELS;
 use vortex_session::VortexSession;
 
-use crate::Precision;
+use crate::EqMode;
 use crate::arrays::varbin::compute::rules::PARENT_RULES;
 use crate::hash::ArrayEq;
 use crate::hash::ArrayHash;
@@ -54,14 +54,14 @@ pub struct VarBinMetadata {
 }
 
 impl ArrayHash for VarBinData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
-        self.bytes().array_hash(state, precision);
+    fn array_hash<H: Hasher>(&self, state: &mut H, accuracy: EqMode) {
+        self.bytes().array_hash(state, accuracy);
     }
 }
 
 impl ArrayEq for VarBinData {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
-        self.bytes().array_eq(other.bytes(), precision)
+    fn array_eq(&self, other: &Self, accuracy: EqMode) -> bool {
+        self.bytes().array_eq(other.bytes(), accuracy)
     }
 }
 
diff --git a/vortex-array/src/arrays/varbinview/array.rs b/vortex-array/src/arrays/varbinview/array.rs
index e302c9341d2..3ba90409939 100644
--- a/vortex-array/src/arrays/varbinview/array.rs
+++ b/vortex-array/src/arrays/varbinview/array.rs
@@ -18,6 +18,8 @@ use vortex_error::vortex_err;
 use vortex_error::vortex_panic;
 
 use crate::ArraySlots;
+use crate::LEGACY_SESSION;
+use crate::VortexSessionExecute;
 use crate::array::Array;
 use crate::array::ArrayParts;
 use crate::array::TypedArrayRef;
@@ -316,11 +318,7 @@ impl VarBinViewData {
     where
         F: Fn(&[u8]) -> bool,
     {
-        for (idx, &view) in views.iter().enumerate() {
-            if validity.is_null(idx)? {
-                continue;
-            }
-
+        let validate_view = |idx: usize, view: &BinaryView| -> VortexResult<()> {
             if view.is_inlined() {
                 // Validate the inline bytestring
                 let bytes = &view.as_inlined().data[..view.len() as usize];
@@ -364,6 +362,30 @@ impl VarBinViewData {
                     InvalidArgument: "view at index {idx}: outlined bytes fails utf-8 validation"
                 );
             }
+            Ok(())
+        };
+
+        match validity {
+            // Array-backed validity is the only variant that needs an execution context: execute it
+            // into a mask once and zip it with the views, validating only the valid (non-null)
+            // entries.
+            Validity::Array(_) => {
+                let mut ctx = LEGACY_SESSION.create_execution_ctx();
+                let mask = validity.execute_mask(views.len(), &mut ctx)?;
+                for ((idx, view), valid) in views.iter().enumerate().zip(mask.iter()) {
+                    if valid {
+                        validate_view(idx, view)?;
+                    }
+                }
+            }
+            // Every entry is null, so there is nothing to validate.
+            Validity::AllInvalid => {}
+            // No nulls: validate every view.
+            Validity::NonNullable | Validity::AllValid => {
+                for (idx, view) in views.iter().enumerate() {
+                    validate_view(idx, view)?;
+                }
+            }
         }
 
         Ok(())
diff --git a/vortex-array/src/arrays/varbinview/build_views.rs b/vortex-array/src/arrays/varbinview/build_views.rs
index 87f5c84706b..4c35aab721a 100644
--- a/vortex-array/src/arrays/varbinview/build_views.rs
+++ b/vortex-array/src/arrays/varbinview/build_views.rs
@@ -24,15 +24,87 @@ pub fn offsets_to_lengths<P: NativePType>(offsets: &[P]) -> Buffer<P> {
 /// Maximum number of buffer bytes that can be referenced by a single `BinaryView`
 pub const MAX_BUFFER_LEN: usize = i32::MAX as usize;
 
-/// Split a large buffer of input `bytes` holding string data
+/// Split a large buffer of input `bytes` holding string data into `VarBinView` buffers and views.
+///
+/// `max_buffer_len` must not exceed [`MAX_BUFFER_LEN`], since every view offset is stored in a
+/// `u32` and offsets are bounded by `max_buffer_len`.
 pub fn build_views<P: NativePType + AsPrimitive<usize>>(
     start_buf_index: u32,
     max_buffer_len: usize,
-    mut bytes: ByteBufferMut,
+    bytes: ByteBufferMut,
+    lens: &[P],
+) -> (Vec<ByteBuffer>, Buffer<BinaryView>) {
+    assert!(
+        max_buffer_len <= MAX_BUFFER_LEN,
+        "max_buffer_len cannot exceed MAX_BUFFER_LEN, offsets must fit in u32"
+    );
+
+    if bytes.len() <= max_buffer_len {
+        // Common case: the whole decoded heap fits within a single buffer, so no rollover can occur
+        // (`bytes.len()` is the total decoded size and therefore an upper bound on every offset).
+        build_views_single_buffer(start_buf_index, bytes, lens)
+    } else {
+        build_views_rolling(start_buf_index, max_buffer_len, bytes, lens)
+    }
+}
+
+/// Build views when the whole heap fits in a single output buffer.
+///
+/// Because no rollover can occur, the hot loop drops the per-element rollover branch and constructs
+/// reference views inline, avoiding the out-of-line `BinaryView::make_view` call for the common
+/// long-string case. Every offset is bounded by `bytes.len()`, which the caller has guaranteed is
+/// at most [`MAX_BUFFER_LEN`], so the `usize -> u32` conversions cannot truncate.
+fn build_views_single_buffer<P: NativePType + AsPrimitive<usize>>(
+    start_buf_index: u32,
+    bytes: ByteBufferMut,
     lens: &[P],
 ) -> (Vec<ByteBuffer>, Buffer<BinaryView>) {
     let mut views = BufferMut::<BinaryView>::with_capacity(lens.len());
 
+    let data = bytes.as_slice();
+    let mut offset = 0usize;
+    // Write directly into the reserved spare capacity rather than `push_unchecked`. The latter
+    // advances the backing buffer's length on every call, which the optimizer cannot prove is
+    // loop-invariant, so it reloads and rewrites the output cursor through the stack each
+    // iteration. Writing into the spare slice keeps the cursor in a register and the length is
+    // set once after the loop.
+    let spare = views.spare_capacity_mut();
+    for (slot, &len) in spare.iter_mut().zip(lens) {
+        let len = len.as_();
+        let value = &data[offset..offset + len];
+        let view = if len > BinaryView::MAX_INLINED_SIZE {
+            let mut prefix = [0u8; 4];
+            prefix.copy_from_slice(&value[..4]);
+            BinaryView::new_ref(len.as_(), prefix, start_buf_index, offset.as_())
+        } else {
+            BinaryView::make_view(value, start_buf_index, offset.as_())
+        };
+        slot.write(view);
+        offset += len;
+    }
+    // SAFETY: the loop initialized exactly `lens.len()` contiguous views (`spare` has at least
+    //  `lens.len()` slots, and `zip` stops at the shorter operand).
+    unsafe { views.set_len(lens.len()) };
+
+    let buffers = if bytes.is_empty() {
+        Vec::new()
+    } else {
+        vec![bytes.freeze()]
+    };
+    (buffers, views.freeze())
+}
+
+/// Build views when the heap exceeds `max_buffer_len` and must be split across multiple buffers.
+///
+/// The buffer is rolled over every `max_buffer_len` bytes so that no view offset overflows the
+/// `u32` offset field.
+fn build_views_rolling<P: NativePType + AsPrimitive<usize>>(
+    start_buf_index: u32,
+    max_buffer_len: usize,
+    mut bytes: ByteBufferMut,
+    lens: &[P],
+) -> (Vec<ByteBuffer>, Buffer<BinaryView>) {
+    let mut views = BufferMut::<BinaryView>::with_capacity(lens.len());
     let mut buffers = Vec::new();
     let mut buf_index = start_buf_index;
 
@@ -66,12 +138,275 @@ pub fn build_views<P: NativePType + AsPrimitive<usize>>(
 
 #[cfg(test)]
 mod tests {
+    use rstest::rstest;
     use vortex_buffer::ByteBuffer;
     use vortex_buffer::ByteBufferMut;
 
     use crate::arrays::varbinview::BinaryView;
+    use crate::arrays::varbinview::build_views::MAX_BUFFER_LEN;
     use crate::arrays::varbinview::build_views::build_views;
 
+    /// Concatenate `values` into a single byte heap and return it alongside the per-element lengths,
+    /// matching the `(bytes, lens)` inputs that `build_views` consumes.
+    fn flatten(values: &[&[u8]]) -> (ByteBufferMut, Vec<u32>) {
+        let mut bytes = ByteBufferMut::empty();
+        let mut lens = Vec::with_capacity(values.len());
+        for v in values {
+            bytes.extend_from_slice(v);
+            lens.push(u32::try_from(v.len()).unwrap());
+        }
+        (bytes, lens)
+    }
+
+    /// Reconstruct the logical value behind each view by dereferencing it through the output
+    /// buffers. The first buffer corresponds to `start_buf_index`, so buffer indices are rebased by
+    /// that amount. This is the core correctness invariant: regardless of which code path built the
+    /// views, every view must point back at its original bytes.
+    fn reconstruct(
+        buffers: &[ByteBuffer],
+        views: &[BinaryView],
+        start_buf_index: u32,
+    ) -> Vec<Vec<u8>> {
+        views
+            .iter()
+            .map(|view| {
+                if view.is_inlined() {
+                    view.as_inlined().value().to_vec()
+                } else {
+                    let r = view.as_view();
+                    let buf = &buffers[(r.buffer_index - start_buf_index) as usize];
+                    buf[r.as_range()].to_vec()
+                }
+            })
+            .collect()
+    }
+
+    /// The single-buffer fast path (`bytes.len() <= max_buffer_len`) must reproduce every input
+    /// value exactly, emit a single output buffer holding the untouched heap, and reference only
+    /// `start_buf_index`. We cover a spread of value sets that mix inlined (<= 12 bytes) and
+    /// reference (> 12 bytes) lengths, including the 12/13 byte inline boundary, empty values, and a
+    /// fully-inlined set.
+    #[rstest]
+    #[case::mixed(&[b"a".as_slice(), b"this is a long reference value", b"short", b"another long value here!!"])]
+    #[case::inline_boundary(&[&[b'x'; 12] as &[u8], &[b'y'; 13], &[b'z'; 12], &[b'w'; 13]])]
+    #[case::all_inlined(&[b"".as_slice(), b"a", b"bb", b"ccc", b"dddddddddddd"])]
+    #[case::all_reference(&[&[b'a'; 100] as &[u8], &[b'b'; 50], &[b'c'; 4096]])]
+    #[case::empty_values_interleaved(&[b"".as_slice(), b"a long value that is referenced", b"", b"", b"trailing long reference value"])]
+    #[case::single_long(&[&[7u8; 1 << 16] as &[u8]])]
+    fn fast_path_roundtrip(#[case] values: &[&[u8]]) {
+        let (bytes, lens) = flatten(values);
+        let total = bytes.len();
+        let start_buf_index = 3;
+
+        // `max_buffer_len` strictly greater than the heap forces the single-buffer fast path.
+        let (buffers, views) = build_views(start_buf_index, total + 1, bytes, &lens);
+
+        assert_eq!(views.len(), values.len());
+        if total == 0 {
+            assert!(buffers.is_empty(), "empty heap must not allocate a buffer");
+        } else {
+            assert_eq!(buffers.len(), 1, "whole heap must stay in one buffer");
+            // The fast path freezes the input heap unchanged.
+            let concatenated: Vec<u8> = values.concat();
+            assert_eq!(buffers[0].as_slice(), concatenated.as_slice());
+        }
+        for view in views.iter() {
+            if !view.is_inlined() {
+                assert_eq!(view.as_view().buffer_index, start_buf_index);
+            }
+        }
+
+        let expected: Vec<Vec<u8>> = values.iter().map(|v| v.to_vec()).collect();
+        assert_eq!(reconstruct(&buffers, &views, start_buf_index), expected);
+    }
+
+    /// Offsets and sizes are written into the `u32` `Ref` fields via `as_` truncation, so we must
+    /// confirm they stay correct once the running offset grows well past the 16-bit range (i.e. is
+    /// not narrowed to a smaller width). A ~9 MiB heap pushes offsets above 2^23 while remaining far
+    /// below `MAX_BUFFER_LEN`; each value encodes its index in its first bytes so a misplaced offset
+    /// would reconstruct the wrong bytes.
+    #[test]
+    fn fast_path_large_offsets() {
+        const N: usize = 9000;
+        const LEN: usize = 1000;
+        // The final offset is (N - 1) * LEN, which must exceed 2^23 to be a meaningful check.
+        const _: () = assert!((N - 1) * LEN > (1 << 23));
+
+        let values: Vec<Vec<u8>> = (0..N)
+            .map(|i| {
+                let mut v = vec![0u8; LEN];
+                v[..4].copy_from_slice(&u32::try_from(i).unwrap().to_le_bytes());
+                v
+            })
+            .collect();
+        let refs: Vec<&[u8]> = values.iter().map(|v| v.as_slice()).collect();
+
+        let (bytes, lens) = flatten(&refs);
+        let total = bytes.len();
+
+        let (buffers, views) = build_views(0, total + 1, bytes, &lens);
+
+        assert_eq!(buffers.len(), 1);
+        // The recorded offset must equal the cumulative byte position, exactly, for every view.
+        for (i, view) in views.iter().enumerate() {
+            let r = view.as_view();
+            assert_eq!(r.offset as usize, i * LEN, "wrong offset for view {i}");
+            assert_eq!(r.size as usize, LEN);
+        }
+        assert_eq!(reconstruct(&buffers, &views, 0), values);
+    }
+
+    /// The fast path is taken when `bytes.len() <= max_buffer_len`, so equality at the boundary must
+    /// still produce a single buffer (not roll over to the slow path).
+    #[test]
+    fn fast_path_taken_at_exact_boundary() {
+        let (bytes, lens) =
+            flatten(&[b"this value is definitely long", b"and so is this one here"]);
+        let total = bytes.len();
+
+        let (buffers, views) = build_views(0, total, bytes, &lens);
+
+        assert_eq!(
+            buffers.len(),
+            1,
+            "len == max_buffer_len must stay on fast path"
+        );
+        assert_eq!(views.len(), 2);
+    }
+
+    /// For the same logical data, the fast path (single buffer) and the slow rollover path must
+    /// reconstruct identical values. Driving the slow path with a small `max_buffer_len` forces
+    /// buffer splitting while leaving the recovered values unchanged.
+    #[test]
+    fn fast_and_slow_paths_agree() {
+        let values: &[&[u8]] = &[
+            b"first long reference value",
+            b"tiny",
+            b"second long reference value!!",
+            b"third looooong reference value",
+        ];
+        let expected: Vec<Vec<u8>> = values.iter().map(|v| v.to_vec()).collect();
+
+        let (fast_bytes, lens) = flatten(values);
+        let total = fast_bytes.len();
+        let (fast_buffers, fast_views) = build_views(0, total + 1, fast_bytes, &lens);
+        assert_eq!(fast_buffers.len(), 1);
+        assert_eq!(reconstruct(&fast_buffers, &fast_views, 0), expected);
+
+        // Force the rollover path: a small cap (>= the longest value) that the total heap exceeds.
+        let longest = values.iter().map(|v| v.len()).max().unwrap();
+        let (slow_bytes, _) = flatten(values);
+        let (slow_buffers, slow_views) = build_views(0, longest, slow_bytes, &lens);
+        assert!(
+            slow_buffers.len() > 1,
+            "small cap should split into many buffers"
+        );
+        assert_eq!(reconstruct(&slow_buffers, &slow_views, 0), expected);
+
+        // Same logical contents regardless of how the heap was partitioned.
+        assert_eq!(
+            reconstruct(&fast_buffers, &fast_views, 0),
+            reconstruct(&slow_buffers, &slow_views, 0)
+        );
+    }
+
+    /// Empty input must yield no buffers and no views, exercising the `bytes.is_empty()` branch.
+    #[test]
+    fn fast_path_empty_input() {
+        let lens: Vec<u32> = Vec::new();
+        let (buffers, views) = build_views(0, 1024, ByteBufferMut::empty(), &lens);
+        assert!(buffers.is_empty());
+        assert!(views.is_empty());
+    }
+
+    /// The fast path must produce views byte-identical to the value-inspecting `make_view`, which is
+    /// what the slow path uses. This pins the inline/reference decision and field layout.
+    #[test]
+    fn fast_path_matches_make_view() {
+        let values: &[&[u8]] = &[b"inline", b"this is a long reference value", b""];
+        let (bytes, lens) = flatten(values);
+        let total = bytes.len();
+        let (_buffers, views) = build_views(0, total + 1, bytes, &lens);
+
+        let expected = [
+            BinaryView::make_view(b"inline", 0, 0),
+            BinaryView::make_view(b"this is a long reference value", 0, 6),
+            BinaryView::make_view(b"", 0, 36),
+        ];
+        assert_eq!(views.as_slice(), &expected);
+    }
+
+    // TODO(someone): ideally CI would run this in release mode as well, since debug builds make the
+    // ~2.25 GiB allocation and fill loop substantially slower.
+    /// Slow regression for the single-buffer fast-path guard. The fast path is only valid when the
+    /// whole heap fits in one buffer (`bytes.len() <= max_buffer_len`); once the heap exceeds
+    /// [`MAX_BUFFER_LEN`] (`i32::MAX`, ~2.0 GiB) `build_views` must roll the heap into multiple
+    /// buffers, resetting the per-buffer offset, so no view references an offset past the
+    /// `i32`-bounded buffer limit.
+    ///
+    /// We build a heap just past `i32::MAX` and assert it rolls over into more than one buffer, that
+    /// no buffer exceeds `MAX_BUFFER_LEN`, and that values straddling the rollover boundary (where
+    /// the second buffer's offsets restart from zero) reconstruct exactly. If the guard regressed and
+    /// the fast path swallowed the whole heap, it would emit a single >2 GiB buffer with offsets past
+    /// `i32::MAX`, which the buffer-count and buffer-size assertions catch.
+    ///
+    /// Allocates ~2.25 GiB, so it is gated to CI and skipped when `VORTEX_SKIP_SLOW_TESTS` is set:
+    ///
+    /// ```text
+    /// CI=1 cargo test --release -p vortex-array build_views_offsets_overflow
+    /// ```
+    ///
+    /// [`MAX_BUFFER_LEN`]: super::MAX_BUFFER_LEN
+    #[test_with::env(CI)]
+    #[test_with::no_env(VORTEX_SKIP_SLOW_TESTS)]
+    fn build_views_offsets_overflow_i32() {
+        const STRING_LEN: usize = 64 * 1024;
+        // Comfortably past MAX_BUFFER_LEN (`i32::MAX` ~= 2.0 GiB) so the heap must roll over.
+        const TOTAL_BYTES: usize = (1usize << 31) + (256 << 20); // ~2.25 GiB
+        const N: usize = TOTAL_BYTES / STRING_LEN;
+
+        // Each value's first 8 bytes encode its row index, so a misrouted offset is detectable.
+        let nth_string = |i: usize| {
+            let mut s = vec![b'x'; STRING_LEN];
+            s[..8].copy_from_slice(&(i as u64).to_le_bytes());
+            s
+        };
+
+        let mut bytes = ByteBufferMut::with_capacity(N * STRING_LEN);
+        let mut value = vec![b'x'; STRING_LEN];
+        for i in 0..N {
+            value[..8].copy_from_slice(&(i as u64).to_le_bytes());
+            bytes.extend_from_slice(&value);
+        }
+
+        let lens = vec![u32::try_from(STRING_LEN).unwrap(); N];
+        let (buffers, views) = build_views(0, MAX_BUFFER_LEN, bytes, &lens);
+
+        assert_eq!(views.len(), N);
+        assert!(
+            buffers.len() >= 2,
+            "heap exceeding MAX_BUFFER_LEN must roll over into multiple buffers, got {}",
+            buffers.len()
+        );
+        for (i, b) in buffers.iter().enumerate() {
+            assert!(
+                b.len() <= MAX_BUFFER_LEN,
+                "buffer {i} of {} bytes exceeds MAX_BUFFER_LEN",
+                b.len()
+            );
+        }
+
+        // The boundary row is the first whose offset would cross MAX_BUFFER_LEN on the fast path.
+        let boundary = MAX_BUFFER_LEN / STRING_LEN;
+        for i in [0, boundary - 1, boundary, boundary + 1, N / 2, N - 1] {
+            let view = &views[i];
+            let r = view.as_view();
+            let got = &buffers[r.buffer_index as usize][r.as_range()];
+            assert_eq!(got, nth_string(i).as_slice(), "value mismatch at row {i}");
+            assert_eq!(r.size as usize, STRING_LEN);
+        }
+    }
+
     #[test]
     fn test_to_canonical_large() {
         // We are testing generating views for raw data that should look like
@@ -107,4 +442,15 @@ mod tests {
             ]
         )
     }
+
+    #[test]
+    #[should_panic(expected = "max_buffer_len cannot exceed MAX_BUFFER_LEN")]
+    fn test_max_buffer_len_too_large_panics() {
+        build_views(
+            0,
+            MAX_BUFFER_LEN + 1,
+            ByteBufferMut::copy_from("abc"),
+            &[3u32],
+        );
+    }
 }
diff --git a/vortex-array/src/arrays/varbinview/compute/slice.rs b/vortex-array/src/arrays/varbinview/compute/slice.rs
index 19f5a0d41b0..e53da7a6eb3 100644
--- a/vortex-array/src/arrays/varbinview/compute/slice.rs
+++ b/vortex-array/src/arrays/varbinview/compute/slice.rs
@@ -16,16 +16,19 @@ use crate::arrays::varbinview::BinaryView;
 
 impl SliceReduce for VarBinView {
     fn slice(array: ArrayView<'_, Self>, range: Range<usize>) -> VortexResult<Option<ArrayRef>> {
-        Ok(Some(
-            VarBinViewArray::new_handle(
-                array
-                    .views_handle()
-                    .slice_typed::<BinaryView>(range.clone()),
-                Arc::clone(array.data_buffers()),
-                array.dtype().clone(),
-                array.validity()?.slice(range)?,
-            )
-            .into_array(),
-        ))
+        let views = array
+            .views_handle()
+            .slice_typed::<BinaryView>(range.clone());
+        let data_buffers = Arc::clone(array.data_buffers());
+        let dtype = array.dtype().clone();
+        let validity = array.validity()?.slice(range)?;
+
+        // Safety:
+        // range is validated within bounds, and is shared between all children.
+        let array = unsafe {
+            VarBinViewArray::new_handle_unchecked(views, data_buffers, dtype, validity).into_array()
+        };
+
+        Ok(Some(array))
     }
 }
diff --git a/vortex-array/src/arrays/varbinview/compute/zip.rs b/vortex-array/src/arrays/varbinview/compute/zip.rs
index f4a5c26a9ce..9c198fe6f2c 100644
--- a/vortex-array/src/arrays/varbinview/compute/zip.rs
+++ b/vortex-array/src/arrays/varbinview/compute/zip.rs
@@ -177,6 +177,7 @@ fn push_range(
     }
 }
 
+#[inline]
 fn push_view(
     view: BinaryView,
     buffer_lookup: &[u32],
diff --git a/vortex-array/src/arrays/varbinview/view.rs b/vortex-array/src/arrays/varbinview/view.rs
index 38cbd2798c6..1b07baa4576 100644
--- a/vortex-array/src/arrays/varbinview/view.rs
+++ b/vortex-array/src/arrays/varbinview/view.rs
@@ -150,17 +150,15 @@ impl BinaryView {
             12 => Self {
                 inlined: Inlined::new::<12>(value),
             },
-            _ => Self {
-                _ref: Ref {
-                    size: u32::try_from(value.len()).vortex_expect("value length must fit in u32"),
-                    prefix: value[0..4]
-                        .try_into()
-                        .ok()
-                        .vortex_expect("prefix must be exactly 4 bytes"),
-                    buffer_index: block,
-                    offset,
-                },
-            },
+            _ => Self::new_ref(
+                u32::try_from(value.len()).vortex_expect("value length must fit in u32"),
+                value[0..4]
+                    .try_into()
+                    .ok()
+                    .vortex_expect("prefix must be exactly 4 bytes"),
+                block,
+                offset,
+            ),
         }
     }
 
@@ -170,6 +168,27 @@ impl BinaryView {
         Self { le_bytes: [0; 16] }
     }
 
+    /// Create a reference view directly from its components, without inspecting the value.
+    ///
+    /// `size` must be greater than [`MAX_INLINED_SIZE`], and `prefix` must hold the first four
+    /// bytes of the value. This is the fast path for bulk view construction where the caller has
+    /// already established that the value is too long to inline; it assembles the 16-byte view as a
+    /// single `u128` so the compiler can emit one wide store per view.
+    ///
+    /// [`MAX_INLINED_SIZE`]: Self::MAX_INLINED_SIZE
+    #[inline]
+    pub fn new_ref(size: u32, prefix: [u8; 4], buffer_index: u32, offset: u32) -> Self {
+        debug_assert!(size as usize > Self::MAX_INLINED_SIZE);
+        // Matches the little-endian field order of `Ref` (size, prefix, buffer_index, offset),
+        // consistent with `le_bytes` and the `From<u128>`/`as_u128` representation.
+        Self::from(
+            u128::from(size)
+                | (u128::from(u32::from_le_bytes(prefix)) << 32)
+                | (u128::from(buffer_index) << 64)
+                | (u128::from(offset) << 96),
+        )
+    }
+
     /// Create a new inlined binary view
     ///
     /// # Panics
@@ -278,3 +297,36 @@ impl fmt::Debug for BinaryView {
         s.finish()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[rstest::rstest]
+    // Just past the inline boundary, typical, and large values.
+    #[case(13, 7, 42)]
+    #[case(20, 7, 42)]
+    #[case(255, 7, 42)]
+    #[case(4096, 7, 42)]
+    // Zero buffer index/offset and the `u32` extremes, to confirm the `u128` field assembly does
+    // not overflow into neighbouring fields.
+    #[case(13, 0, 0)]
+    #[case(13, u32::MAX, u32::MAX)]
+    fn new_ref_matches_make_view(#[case] len: u32, #[case] buffer_index: u32, #[case] offset: u32) {
+        // `new_ref` assembles the reference view as a `u128`; it must be byte-identical to the
+        // value-inspecting `make_view` for any value longer than the inline limit.
+        let value: Vec<u8> = (0..len)
+            .map(|i| u8::try_from(i % 251).vortex_expect("i % 251 fits in u8"))
+            .collect();
+        let prefix = [value[0], value[1], value[2], value[3]];
+        let made = BinaryView::make_view(&value, buffer_index, offset);
+        let built = BinaryView::new_ref(len, prefix, buffer_index, offset);
+        assert_eq!(made.as_u128(), built.as_u128(), "mismatch at len {len}");
+        assert!(!built.is_inlined());
+        let r = built.as_view();
+        assert_eq!(r.size, len);
+        assert_eq!(r.prefix, prefix);
+        assert_eq!(r.buffer_index, buffer_index);
+        assert_eq!(r.offset, offset);
+    }
+}
diff --git a/vortex-array/src/arrays/varbinview/vtable/mod.rs b/vortex-array/src/arrays/varbinview/vtable/mod.rs
index 45db5d904ac..c093b9c0203 100644
--- a/vortex-array/src/arrays/varbinview/vtable/mod.rs
+++ b/vortex-array/src/arrays/varbinview/vtable/mod.rs
@@ -16,9 +16,9 @@ use vortex_session::VortexSession;
 use vortex_session::registry::CachedId;
 
 use crate::ArrayRef;
+use crate::EqMode;
 use crate::ExecutionCtx;
 use crate::ExecutionResult;
-use crate::Precision;
 use crate::array::Array;
 use crate::array::ArrayId;
 use crate::array::ArrayView;
@@ -44,23 +44,23 @@ pub type VarBinViewArray = Array<VarBinView>;
 pub struct VarBinView;
 
 impl ArrayHash for VarBinViewData {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, accuracy: EqMode) {
         for buffer in self.buffers.iter() {
-            buffer.array_hash(state, precision);
+            buffer.array_hash(state, accuracy);
         }
-        self.views.array_hash(state, precision);
+        self.views.array_hash(state, accuracy);
     }
 }
 
 impl ArrayEq for VarBinViewData {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, accuracy: EqMode) -> bool {
         self.buffers.len() == other.buffers.len()
             && self
                 .buffers
                 .iter()
                 .zip(other.buffers.iter())
-                .all(|(a, b)| a.array_eq(b, precision))
-            && self.views.array_eq(&other.views, precision)
+                .all(|(a, b)| a.array_eq(b, accuracy))
+            && self.views.array_eq(&other.views, accuracy)
     }
 }
 
diff --git a/vortex-array/src/arrow/convert.rs b/vortex-array/src/arrow/convert.rs
index 419caacd82d..3d536402e5c 100644
--- a/vortex-array/src/arrow/convert.rs
+++ b/vortex-array/src/arrow/convert.rs
@@ -58,14 +58,15 @@ use arrow_buffer::buffer::NullBuffer;
 use arrow_buffer::buffer::OffsetBuffer;
 use arrow_schema::DataType;
 use arrow_schema::TimeUnit as ArrowTimeUnit;
-use itertools::Itertools;
 use vortex_buffer::Alignment;
 use vortex_buffer::BitBuffer;
 use vortex_buffer::Buffer;
 use vortex_buffer::ByteBuffer;
-use vortex_error::VortexExpect as _;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_ensure_eq;
+use vortex_error::vortex_err;
 use vortex_error::vortex_panic;
 
 use crate::ArrayRef;
@@ -141,7 +142,7 @@ macro_rules! impl_from_arrow_primitive {
         impl FromArrowArray<&ArrowPrimitiveArray<$T>> for ArrayRef {
             fn from_arrow(value: &ArrowPrimitiveArray<$T>, nullable: bool) -> VortexResult<Self> {
                 let buffer = Buffer::from_arrow_scalar_buffer(value.values().clone());
-                let validity = nulls(value.nulls(), nullable);
+                let validity = nulls(value.nulls(), nullable)?;
                 Ok(PrimitiveArray::new(buffer, validity).into_array())
             }
         }
@@ -167,7 +168,7 @@ impl FromArrowArray<&ArrowPrimitiveArray<Decimal32Type>> for ArrayRef {
     ) -> VortexResult<Self> {
         let decimal_type = DecimalDType::new(array.precision(), array.scale());
         let buffer = Buffer::from_arrow_scalar_buffer(array.values().clone());
-        let validity = nulls(array.nulls(), nullable);
+        let validity = nulls(array.nulls(), nullable)?;
         Ok(DecimalArray::new(buffer, decimal_type, validity).into_array())
     }
 }
@@ -179,7 +180,7 @@ impl FromArrowArray<&ArrowPrimitiveArray<Decimal64Type>> for ArrayRef {
     ) -> VortexResult<Self> {
         let decimal_type = DecimalDType::new(array.precision(), array.scale());
         let buffer = Buffer::from_arrow_scalar_buffer(array.values().clone());
-        let validity = nulls(array.nulls(), nullable);
+        let validity = nulls(array.nulls(), nullable)?;
         Ok(DecimalArray::new(buffer, decimal_type, validity).into_array())
     }
 }
@@ -191,7 +192,7 @@ impl FromArrowArray<&ArrowPrimitiveArray<Decimal128Type>> for ArrayRef {
     ) -> VortexResult<Self> {
         let decimal_type = DecimalDType::new(array.precision(), array.scale());
         let buffer = Buffer::from_arrow_scalar_buffer(array.values().clone());
-        let validity = nulls(array.nulls(), nullable);
+        let validity = nulls(array.nulls(), nullable)?;
         Ok(DecimalArray::new(buffer, decimal_type, validity).into_array())
     }
 }
@@ -208,7 +209,7 @@ impl FromArrowArray<&ArrowPrimitiveArray<Decimal256Type>> for ArrayRef {
         //  of either type.
         let buffer =
             unsafe { std::mem::transmute::<Buffer<arrow_buffer::i256>, Buffer<i256>>(buffer) };
-        let validity = nulls(array.nulls(), nullable);
+        let validity = nulls(array.nulls(), nullable)?;
         Ok(DecimalArray::new(buffer, decimal_type, validity).into_array())
     }
 }
@@ -220,7 +221,7 @@ macro_rules! impl_from_arrow_temporal {
                 value: &ArrowPrimitiveArray<$T>,
                 nullable: bool,
             ) -> vortex_error::VortexResult<Self> {
-                Ok(temporal_array(value, nullable))
+                temporal_array(value, nullable)
             }
         }
     };
@@ -242,17 +243,20 @@ impl_from_arrow_temporal!(Time64NanosecondType);
 impl_from_arrow_temporal!(Date32Type);
 impl_from_arrow_temporal!(Date64Type);
 
-fn temporal_array<T: ArrowPrimitiveType>(value: &ArrowPrimitiveArray<T>, nullable: bool) -> ArrayRef
+fn temporal_array<T: ArrowPrimitiveType>(
+    value: &ArrowPrimitiveArray<T>,
+    nullable: bool,
+) -> VortexResult<ArrayRef>
 where
     T::Native: NativePType,
 {
     let arr = PrimitiveArray::new(
         Buffer::from_arrow_scalar_buffer(value.values().clone()),
-        nulls(value.nulls(), nullable),
+        nulls(value.nulls(), nullable)?,
     )
     .into_array();
 
-    match value.data_type() {
+    Ok(match value.data_type() {
         DataType::Timestamp(time_unit, tz) => {
             TemporalArray::new_timestamp(arr, time_unit.into(), tz.clone()).into()
         }
@@ -263,7 +267,7 @@ where
         DataType::Duration(_) => unimplemented!(),
         DataType::Interval(_) => unimplemented!(),
         _ => vortex_panic!("Invalid temporal type: {}", value.data_type()),
-    }
+    })
 }
 
 impl<T: ByteArrayType> FromArrowArray<&GenericByteArray<T>> for ArrayRef
@@ -282,7 +286,7 @@ where
                 value.offsets().clone().into_array(),
                 ByteBuffer::from_arrow_buffer(value.values().clone(), Alignment::of::<u8>()),
                 dtype,
-                nulls(value.nulls(), nullable),
+                nulls(value.nulls(), nullable)?,
             )
         }
         .into_array())
@@ -314,7 +318,7 @@ impl<T: ByteViewType> FromArrowArray<&GenericByteViewArray<T>> for ArrayRef {
                         .collect::<Vec<_>>(),
                 ),
                 dtype,
-                nulls(value.nulls(), nullable),
+                nulls(value.nulls(), nullable)?,
             )
             .into_array()
         })
@@ -325,17 +329,17 @@ impl FromArrowArray<&ArrowBooleanArray> for ArrayRef {
     fn from_arrow(value: &ArrowBooleanArray, nullable: bool) -> VortexResult<Self> {
         Ok(BoolArray::new(
             value.values().clone().into(),
-            nulls(value.nulls(), nullable),
+            nulls(value.nulls(), nullable)?,
         )
         .into_array())
     }
 }
 
 /// Strip out the nulls from this array and return a new array without nulls.
-pub(crate) fn remove_nulls(data: arrow_data::ArrayData) -> arrow_data::ArrayData {
+pub(crate) fn remove_nulls(data: arrow_data::ArrayData) -> VortexResult<arrow_data::ArrayData> {
     if data.null_count() == 0 {
         // No nulls to remove, return the array as is
-        return data;
+        return Ok(data);
     }
 
     let children = match data.data_type() {
@@ -345,12 +349,12 @@ pub(crate) fn remove_nulls(data: arrow_data::ArrayData) -> arrow_data::ArrayData
                 .zip(data.child_data().iter())
                 .map(|(field, child_data)| {
                     if field.is_nullable() {
-                        child_data.clone()
+                        Ok(child_data.clone())
                     } else {
                         remove_nulls(child_data.clone())
                     }
                 })
-                .collect_vec(),
+                .collect::<VortexResult<Vec<_>>>()?,
         ),
         DataType::List(f)
         | DataType::LargeList(f)
@@ -360,12 +364,12 @@ pub(crate) fn remove_nulls(data: arrow_data::ArrayData) -> arrow_data::ArrayData
             if !f.is_nullable() =>
         {
             // All list types only have one child
-            assert_eq!(
+            vortex_ensure_eq!(
                 data.child_data().len(),
                 1,
                 "List types should have one child"
             );
-            Some(vec![remove_nulls(data.child_data()[0].clone())])
+            Some(vec![remove_nulls(data.child_data()[0].clone())?])
         }
         _ => None,
     };
@@ -376,7 +380,7 @@ pub(crate) fn remove_nulls(data: arrow_data::ArrayData) -> arrow_data::ArrayData
     }
     builder
         .build()
-        .vortex_expect("reconstructing array without nulls")
+        .map_err(|e| vortex_err!("Failed to reconstruct Arrow array without nulls: {e}"))
 }
 
 impl FromArrowArray<&ArrowStructArray> for ArrayRef {
@@ -391,7 +395,7 @@ impl FromArrowArray<&ArrowStructArray> for ArrayRef {
                     // Arrow pushes down nulls, even into non-nullable fields. So we strip them
                     // out here because Vortex is a little more strict.
                     if c.null_count() > 0 && !field.is_nullable() {
-                        let stripped = make_array(remove_nulls(c.into_data()));
+                        let stripped = make_array(remove_nulls(c.into_data())?);
                         Self::from_arrow(stripped.as_ref(), false)
                     } else {
                         Self::from_arrow(c.as_ref(), field.is_nullable())
@@ -399,7 +403,7 @@ impl FromArrowArray<&ArrowStructArray> for ArrayRef {
                 })
                 .collect::<VortexResult<Vec<_>>>()?,
             value.len(),
-            nulls(value.nulls(), nullable),
+            nulls(value.nulls(), nullable)?,
         )?
         .into_array())
     }
@@ -418,7 +422,7 @@ impl<O: IntegerPType + OffsetSizeTrait> FromArrowArray<&GenericListArray<O>> for
 
         // `offsets` are always non-nullable.
         let offsets = value.offsets().clone().into_array();
-        let nulls = nulls(value.nulls(), nullable);
+        let nulls = nulls(value.nulls(), nullable)?;
 
         Ok(ListArray::try_new(elements, offsets, nulls)?.into_array())
     }
@@ -438,7 +442,7 @@ impl<O: OffsetSizeTrait + NativePType> FromArrowArray<&GenericListViewArray<O>>
         // `offsets` and `sizes` are always non-nullable.
         let offsets = array.offsets().clone().into_array();
         let sizes = array.sizes().clone().into_array();
-        let nulls = nulls(array.nulls(), nullable);
+        let nulls = nulls(array.nulls(), nullable)?;
 
         Ok(ListViewArray::try_new(elements, offsets, sizes, nulls)?.into_array())
     }
@@ -453,7 +457,7 @@ impl FromArrowArray<&ArrowFixedSizeListArray> for ArrayRef {
         Ok(FixedSizeListArray::try_new(
             Self::from_arrow(array.values().as_ref(), field.is_nullable())?,
             *list_size as u32,
-            nulls(array.nulls(), nullable),
+            nulls(array.nulls(), nullable)?,
             array.len(),
         )?
         .into_array())
@@ -466,7 +470,7 @@ impl FromArrowArray<&ArrowMapArray> for ArrayRef {
         // We convert it to a ListArray of structs.
         let entries = Self::from_arrow(value.entries() as &dyn ArrowArray, false)?;
         let offsets = value.offsets().clone().into_array();
-        let nulls = nulls(value.nulls(), nullable);
+        let nulls = nulls(value.nulls(), nullable)?;
 
         Ok(ListArray::try_new(entries, offsets, nulls)?.into_array())
     }
@@ -474,7 +478,10 @@ impl FromArrowArray<&ArrowMapArray> for ArrayRef {
 
 impl FromArrowArray<&ArrowNullArray> for ArrayRef {
     fn from_arrow(value: &ArrowNullArray, nullable: bool) -> VortexResult<Self> {
-        assert!(nullable);
+        vortex_ensure!(
+            nullable,
+            "Cannot convert an Arrow NullArray into a non-nullable Vortex array"
+        );
         Ok(NullArray::new(value.len()).into_array())
     }
 }
@@ -489,9 +496,9 @@ impl<K: ArrowDictionaryKeyType> FromArrowArray<&DictionaryArray<K>> for DictArra
     }
 }
 
-pub(crate) fn nulls(nulls: Option<&NullBuffer>, nullable: bool) -> Validity {
+pub(crate) fn nulls(nulls: Option<&NullBuffer>, nullable: bool) -> VortexResult<Validity> {
     if nullable {
-        nulls
+        Ok(nulls
             .map(|nulls| {
                 if nulls.null_count() == nulls.len() {
                     Validity::AllInvalid
@@ -499,10 +506,15 @@ pub(crate) fn nulls(nulls: Option<&NullBuffer>, nullable: bool) -> Validity {
                     Validity::from(BitBuffer::from(nulls.inner().clone()))
                 }
             })
-            .unwrap_or_else(|| Validity::AllValid)
+            .unwrap_or(Validity::AllValid))
     } else {
-        assert!(nulls.map(|x| x.null_count() == 0).unwrap_or(true));
-        Validity::NonNullable
+        let null_count = nulls.map(NullBuffer::null_count).unwrap_or(0);
+        vortex_ensure_eq!(
+            null_count,
+            0,
+            "Cannot convert an Arrow array containing {null_count} nulls into a non-nullable Vortex array"
+        );
+        Ok(Validity::NonNullable)
     }
 }
 
@@ -1504,8 +1516,48 @@ mod tests {
     }
 
     #[test]
-    #[should_panic]
-    pub fn cannot_handle_nullable_struct_containing_non_nullable_dictionary() {
+    fn non_nullable_request_rejects_nulls() {
+        // Requesting `nullable = false` on an Arrow array that physically contains nulls is a
+        // contradiction and must surface as an error, not a panic.
+        let arrow_array = Int32Array::from(vec![Some(1), None, Some(3)]);
+        assert!(ArrayRef::from_arrow(&arrow_array, false).is_err());
+    }
+
+    #[test]
+    fn non_nullable_request_rejects_null_array() {
+        // An Arrow NullArray is entirely null, so it cannot be converted to a non-nullable
+        // Vortex array.
+        let arrow_array = NullArray::new(5);
+        assert!(ArrayRef::from_arrow(&arrow_array, false).is_err());
+    }
+
+    #[test]
+    fn non_nullable_struct_with_nulls_errors() {
+        // A struct array carrying top-level nulls cannot be converted to a non-nullable Vortex
+        // struct; the struct-level validity reconciliation must error rather than panic.
+        let struct_array = new_null_array(
+            &DataType::Struct(Fields::from(vec![Field::new("a", DataType::Int32, true)])),
+            3,
+        );
+        assert!(ArrayRef::from_arrow(struct_array.as_ref(), false).is_err());
+    }
+
+    #[test]
+    fn non_nullable_list_with_nulls_errors() {
+        // Likewise for a list array with a null entry: requesting a non-nullable list must error
+        // rather than panic.
+        let mut builder = ListBuilder::new(Int32Builder::new());
+        builder.append_value([Some(1), Some(2)]);
+        builder.append_null();
+        let list = builder.finish();
+        assert!(ArrayRef::from_arrow(&list, false).is_err());
+    }
+
+    #[test]
+    pub fn nullable_struct_containing_non_nullable_dictionary_with_nulls_errors() {
+        // `remove_nulls` cannot strip pushed-down nulls out of a non-nullable dictionary field,
+        // so the values end up converted with `nullable = false` while still containing nulls.
+        // This must surface as an error rather than panicking.
         let null_struct_array_with_non_nullable_field = new_null_array(
             &DataType::Struct(Fields::from(vec![Field::new(
                 "non_nullable_deeper_inner",
@@ -1515,7 +1567,9 @@ mod tests {
             1,
         );
 
-        ArrayRef::from_arrow(null_struct_array_with_non_nullable_field.as_ref(), true).unwrap();
+        assert!(
+            ArrayRef::from_arrow(null_struct_array_with_non_nullable_field.as_ref(), true).is_err()
+        );
     }
 
     #[test]
diff --git a/vortex-array/src/arrow/datum.rs b/vortex-array/src/arrow/datum.rs
index 5cea4e3b1a1..b2f047b5948 100644
--- a/vortex-array/src/arrow/datum.rs
+++ b/vortex-array/src/arrow/datum.rs
@@ -105,6 +105,9 @@ impl ArrowDatum for Datum {
 /// # Error
 ///
 /// The provided array must have length
+#[deprecated(
+    note = "Relies on the hidden global `LEGACY_SESSION`; use `from_arrow_columnar` with an explicit `ExecutionCtx` instead"
+)]
 pub fn from_arrow_array_with_len<A>(array: A, len: usize, nullable: bool) -> VortexResult<ArrayRef>
 where
     ArrayRef: FromArrowArray<A>,
@@ -131,3 +134,38 @@ where
     )
     .into_array())
 }
+
+/// Convert an Arrow array to an Array with a specific length, using the provided
+/// [`ExecutionCtx`].
+///
+/// This is useful for compute functions that delegate to Arrow using [Datum],
+/// which will return a scalar (length 1 Arrow array) if the input array is constant.
+///
+/// # Error
+///
+/// The provided array must have length `len` or `1`.
+pub fn from_arrow_columnar<A>(
+    array: A,
+    len: usize,
+    nullable: bool,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ArrayRef>
+where
+    ArrayRef: FromArrowArray<A>,
+{
+    let array = ArrayRef::from_arrow(array, nullable)?;
+    if array.len() == len {
+        return Ok(array);
+    }
+
+    if array.len() != 1 {
+        vortex_panic!(
+            "Array length mismatch, expected {} got {} for encoding {}",
+            len,
+            array.len(),
+            array.encoding_id()
+        );
+    }
+
+    Ok(ConstantArray::new(array.execute_scalar(0, ctx)?, len).into_array())
+}
diff --git a/vortex-array/src/arrow/executor/list.rs b/vortex-array/src/arrow/executor/list.rs
index d59088ade34..e8bf95e14cd 100644
--- a/vortex-array/src/arrow/executor/list.rs
+++ b/vortex-array/src/arrow/executor/list.rs
@@ -33,6 +33,7 @@ use crate::dtype::DType;
 use crate::dtype::NativePType;
 use crate::dtype::Nullability;
 
+#[allow(rustdoc::broken_intra_doc_links)]
 /// Convert a Vortex VarBinArray into an Arrow [`GenericListArray`](arrow_array:array::GenericListArray).
 pub(super) fn to_arrow_list<O: OffsetSizeTrait + NativePType>(
     array: ArrayRef,
@@ -61,7 +62,7 @@ pub(super) fn to_arrow_list<O: OffsetSizeTrait + NativePType>(
             let zctl = if array.is_zero_copy_to_list() {
                 array
             } else {
-                array.rebuild(ListViewRebuildMode::MakeZeroCopyToList)?
+                array.rebuild(ListViewRebuildMode::MakeZeroCopyToList, ctx)?
             };
             return list_view_zctl::<O>(zctl, elements_field, ctx);
         }
@@ -76,11 +77,12 @@ pub(super) fn to_arrow_list<O: OffsetSizeTrait + NativePType>(
     let zctl = if list_view.is_zero_copy_to_list() {
         list_view
     } else {
-        list_view.rebuild(ListViewRebuildMode::MakeZeroCopyToList)?
+        list_view.rebuild(ListViewRebuildMode::MakeZeroCopyToList, ctx)?
     };
     list_view_zctl::<O>(zctl, elements_field, ctx)
 }
 
+#[allow(rustdoc::broken_intra_doc_links)]
 /// Convert a Vortex VarBinArray into an Arrow [`GenericListArray`](arrow_array:array::GenericListArray).
 fn list_to_list<O: OffsetSizeTrait + NativePType>(
     array: &ListArray,
@@ -201,6 +203,7 @@ fn list_view_zctl<O: OffsetSizeTrait + NativePType>(
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;
+    use std::sync::LazyLock;
 
     use arrow_array::Array;
     use arrow_array::GenericListArray;
@@ -209,21 +212,26 @@ mod tests {
     use arrow_schema::Field;
     use vortex_buffer::buffer;
     use vortex_error::VortexResult;
+    use vortex_session::VortexSession;
 
     use crate::Canonical;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::arrays::PrimitiveArray;
     use crate::arrow::ArrowArrayExecutor;
     use crate::arrow::executor::list::ListViewArray;
     use crate::dtype::DType;
     use crate::dtype::Nullability::NonNullable;
+    use crate::session::ArraySession;
     use crate::validity::Validity;
 
+    /// A shared session for these list-executor tests, used to create execution contexts.
+    static SESSION: LazyLock<VortexSession> =
+        LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
     #[test]
     fn test_to_arrow_list_i32() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         // Create a ListViewArray with i32 elements: [[1, 2, 3], [4, 5]]
         let elements = PrimitiveArray::new(buffer![1i32, 2, 3, 4, 5], Validity::NonNullable);
         let offsets = PrimitiveArray::new(buffer![0i32, 3], Validity::NonNullable);
@@ -278,7 +286,7 @@ mod tests {
 
     #[test]
     fn test_to_arrow_list_i64() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         // Create a ListViewArray with i64 offsets: [[10, 20], [30]]
         let elements = PrimitiveArray::new(buffer![10i64, 20, 30], Validity::NonNullable);
         let offsets = PrimitiveArray::new(buffer![0i64, 2], Validity::NonNullable);
@@ -318,7 +326,7 @@ mod tests {
 
     #[test]
     fn test_to_arrow_list_non_zctl() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         // Overlapping lists are NOT zero-copy-to-list, so this exercises the rebuild path.
         // Elements: [1, 2, 3, 4], List 0: [1,2,3], List 1: [2,3,4] (overlap at indices 1-2)
         let elements = PrimitiveArray::new(buffer![1i32, 2, 3, 4], Validity::NonNullable);
@@ -360,7 +368,7 @@ mod tests {
 
     #[test]
     fn test_to_arrow_list_empty_zctl() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let dtype = DType::List(
             Arc::new(DType::Primitive(crate::dtype::PType::I32, NonNullable)),
             NonNullable,
diff --git a/vortex-array/src/arrow/executor/list_view.rs b/vortex-array/src/arrow/executor/list_view.rs
index b77d079f509..5a2cd517b37 100644
--- a/vortex-array/src/arrow/executor/list_view.rs
+++ b/vortex-array/src/arrow/executor/list_view.rs
@@ -54,7 +54,7 @@ pub(super) fn to_arrow_list_view<O: OffsetSizeTrait + IntegerPType>(
         }
     } else if array.upper_bound_density(ctx)? < DEFAULT_REBUILD_DENSITY_THRESHOLD {
         // Overlaps, gaps, or garbage may be present, so a full rebuild is needed to reclaim waste.
-        array.rebuild(ListViewRebuildMode::MakeZeroCopyToList)?
+        array.rebuild(ListViewRebuildMode::MakeZeroCopyToList, ctx)?
     } else {
         array
     };
@@ -109,24 +109,31 @@ fn list_view_to_list_view<O: OffsetSizeTrait + IntegerPType>(
 
 #[cfg(test)]
 mod tests {
+    use std::sync::LazyLock;
+
     use arrow_array::Array;
     use arrow_array::GenericListViewArray;
     use arrow_schema::DataType;
     use arrow_schema::Field;
     use vortex_buffer::buffer;
     use vortex_error::VortexResult;
+    use vortex_session::VortexSession;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::arrow::ArrowArrayExecutor;
     use crate::arrow::executor::list_view::ListViewArray;
     use crate::arrow::executor::list_view::PrimitiveArray;
+    use crate::session::ArraySession;
     use crate::validity::Validity;
 
+    /// A shared session for these list-view-executor tests, used to create execution contexts.
+    static SESSION: LazyLock<VortexSession> =
+        LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
     #[test]
     fn trims_zero_copy_with_significant_trailing_waste() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         // Zero-copy-to-list array with 10 elements but only [0, 4) referenced -> 60% waste.
         // The conversion should trim the elements buffer down to the referenced range.
         let elements = PrimitiveArray::new(
@@ -161,7 +168,7 @@ mod tests {
 
     #[test]
     fn test_to_arrow_listview_i32() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         // Create a ListViewArray with overlapping views: [[1, 2], [2, 3], [3, 4]]
         let elements = PrimitiveArray::new(buffer![1i32, 2, 3, 4], Validity::NonNullable);
         let offsets = PrimitiveArray::new(buffer![0i32, 1, 2], Validity::NonNullable);
@@ -216,7 +223,7 @@ mod tests {
 
     #[test]
     fn test_to_arrow_listview_i64() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         // Create a ListViewArray with nullable elements: [[100], null, [200, 300]]
         let elements = PrimitiveArray::new(buffer![100i64, 200, 300], Validity::NonNullable);
         let offsets = PrimitiveArray::new(buffer![0i64, 1, 1], Validity::NonNullable);
diff --git a/vortex-array/src/arrow/mod.rs b/vortex-array/src/arrow/mod.rs
index 81e5f635bcb..5259005dffc 100644
--- a/vortex-array/src/arrow/mod.rs
+++ b/vortex-array/src/arrow/mod.rs
@@ -26,7 +26,28 @@ use crate::ArrayRef;
 use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
 
+/// Construct a Vortex array from an Arrow array (or other Arrow container) of type `A`.
+///
+/// Implementations reuse the underlying Arrow buffers without copying wherever the Arrow and
+/// Vortex memory layouts allow it.
 pub trait FromArrowArray<A> {
+    /// Convert `array` into a Vortex array whose [`DType`](crate::dtype::DType) has the requested
+    /// `nullable` [`Nullability`](crate::dtype::Nullability).
+    ///
+    /// An Arrow array can carry a validity (null) buffer regardless of whether its schema declares
+    /// the field nullable, so the desired nullability is supplied separately by the caller
+    /// (typically from the corresponding Arrow `Field`'s `is_nullable`). This flag is reconciled
+    /// with the array's physical nulls as follows:
+    ///
+    /// - `nullable == true`: the resulting validity is derived from the array's null buffer, or
+    ///   all-valid when the array has none.
+    /// - `nullable == false`: the array must contain no nulls, and the result is non-nullable.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if `nullable` is `false` but `array` physically contains one or more nulls
+    /// (including an Arrow `NullArray`, which is entirely null), or if the Arrow data type is not
+    /// supported.
     fn from_arrow(array: A, nullable: bool) -> VortexResult<Self>
     where
         Self: Sized;
diff --git a/vortex-array/src/arrow/session.rs b/vortex-array/src/arrow/session.rs
index 9aa83cbbd2e..705f7971f90 100644
--- a/vortex-array/src/arrow/session.rs
+++ b/vortex-array/src/arrow/session.rs
@@ -24,7 +24,6 @@ use std::any::Any;
 use std::fmt::Debug;
 use std::sync::Arc;
 
-use arc_swap::ArcSwap;
 use arrow_array::Array as _;
 use arrow_array::ArrayRef as ArrowArrayRef;
 use arrow_array::RecordBatch;
@@ -44,11 +43,11 @@ use vortex_session::Ref;
 use vortex_session::SessionExt;
 use vortex_session::SessionVar;
 use vortex_session::registry::Id;
-use vortex_utils::aliases::hash_map::HashMap;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
+use crate::arc_swap_map::ArcSwapMap;
 use crate::arrays::StructArray;
 use crate::arrow::FromArrowArray;
 use crate::arrow::convert::nulls;
@@ -61,6 +60,7 @@ use crate::dtype::Nullability;
 use crate::dtype::StructFields;
 use crate::dtype::arrow::FromArrowType;
 use crate::dtype::arrow::to_data_type_naive;
+use crate::dtype::extension::ExtId;
 use crate::extension::datetime::AnyTemporal;
 use crate::extension::uuid::Uuid;
 use crate::validity::Validity;
@@ -154,10 +154,6 @@ pub trait ArrowImportVTable: 'static + Send + Sync + Debug {
 pub type ArrowExportVTableRef = Arc<dyn ArrowExportVTable>;
 pub type ArrowImportVTableRef = Arc<dyn ArrowImportVTable>;
 
-type ExportMap = HashMap<Id, Arc<[ArrowExportVTableRef]>>;
-type ImportMap = HashMap<Id, Arc<[ArrowImportVTableRef]>>;
-type ExportDTypeMap = HashMap<Id, Arc<[ArrowExportVTableRef]>>;
-
 /// Session-scoped registry of Arrow extension plugins.
 ///
 /// Exporters are stored in two indices: one keyed by Arrow extension Id (used for
@@ -169,17 +165,17 @@ type ExportDTypeMap = HashMap<Id, Arc<[ArrowExportVTableRef]>>;
 /// need plugins.
 #[derive(Debug)]
 pub struct ArrowSession {
-    exporters: ArcSwap<ExportMap>,
-    exporters_by_vortex: ArcSwap<ExportDTypeMap>,
-    importers: ArcSwap<ImportMap>,
+    exporters: ArcSwapMap<Id, Arc<[ArrowExportVTableRef]>>,
+    exporters_by_vortex: ArcSwapMap<ExtId, Arc<[ArrowExportVTableRef]>>,
+    importers: ArcSwapMap<Id, Arc<[ArrowImportVTableRef]>>,
 }
 
 impl Default for ArrowSession {
     fn default() -> Self {
         let session = Self {
-            exporters: ArcSwap::from_pointee(ExportMap::default()),
-            exporters_by_vortex: ArcSwap::from_pointee(ExportDTypeMap::default()),
-            importers: ArcSwap::from_pointee(ImportMap::default()),
+            exporters: ArcSwapMap::default(),
+            exporters_by_vortex: ArcSwapMap::default(),
+            importers: ArcSwapMap::default(),
         };
 
         session.register_exporter(Arc::new(Uuid));
@@ -193,56 +189,31 @@ impl ArrowSession {
     /// Register an [`ArrowExportVTable`] under its target Arrow extension Id (for dispatch)
     /// and its source Vortex extension Id (for schema inference).
     pub fn register_exporter(&self, exporter: ArrowExportVTableRef) {
-        Self::insert(
-            &self.exporters,
+        self.exporters.push(
             exporter.arrow_ext_id(),
             ArrowExportVTableRef::clone(&exporter),
         );
-        Self::insert(&self.exporters_by_vortex, exporter.vortex_id(), exporter);
+        self.exporters_by_vortex
+            .push(exporter.vortex_id(), exporter);
     }
 
     /// Register an [`ArrowImportVTable`] under its source Arrow extension name.
     pub fn register_importer(&self, importer: ArrowImportVTableRef) {
-        Self::insert(&self.importers, importer.arrow_ext_id(), importer);
-    }
-
-    fn insert<K, T>(slot: &ArcSwap<HashMap<K, Arc<[T]>>>, key: K, value: T)
-    where
-        K: Clone + Eq + std::hash::Hash,
-        T: Clone,
-    {
-        slot.rcu(move |map| {
-            let mut next = (**map).clone();
-            let entry = next.entry(key.clone()).or_insert_with(|| Arc::from([]));
-            let mut extended: Vec<T> = entry.iter().cloned().collect();
-            extended.push(value.clone());
-            *entry = Arc::from(extended);
-            next
-        });
+        self.importers.push(importer.arrow_ext_id(), importer);
     }
 
     fn exporters(&self, id: &Id) -> Arc<[ArrowExportVTableRef]> {
-        self.exporters
-            .load()
-            .get(id)
-            .cloned()
-            .unwrap_or_else(|| Arc::from([]))
+        self.exporters.get(id).unwrap_or_else(|| Arc::from([]))
     }
 
     fn exporters_by_vortex(&self, id: &Id) -> Arc<[ArrowExportVTableRef]> {
         self.exporters_by_vortex
-            .load()
             .get(id)
-            .cloned()
             .unwrap_or_else(|| Arc::from([]))
     }
 
     fn importers(&self, id: &Id) -> Arc<[ArrowImportVTableRef]> {
-        self.importers
-            .load()
-            .get(id)
-            .cloned()
-            .unwrap_or_else(|| Arc::from([]))
+        self.importers.get(id).unwrap_or_else(|| Arc::from([]))
     }
 
     /// Build the Arrow [`Field`] for a Vortex [`DType`].
@@ -544,14 +515,14 @@ impl ArrowSession {
                         // Arrow pushes nulls into non-nullable fields; strip before recursing
                         // so Vortex's stricter validity invariants are upheld.
                         let inner = if col.null_count() > 0 && !child_field.is_nullable() {
-                            make_array(remove_nulls(col.to_data()))
+                            make_array(remove_nulls(col.to_data())?)
                         } else {
                             ArrowArrayRef::clone(col)
                         };
                         self.from_arrow_array(inner, child_field.as_ref())
                     })
                     .collect::<VortexResult<Vec<_>>>()?;
-                let validity = nulls(arrow_struct.nulls(), field.is_nullable());
+                let validity = nulls(arrow_struct.nulls(), field.is_nullable())?;
                 Ok(
                     StructArray::try_new(names, columns, arrow_struct.len(), validity)?
                         .into_array(),
@@ -562,7 +533,7 @@ impl ArrowSession {
                 let elements = self
                     .from_arrow_array(ArrowArrayRef::clone(list.values()), elem_field.as_ref())?;
                 let offsets = list.offsets().clone().into_array();
-                let validity = nulls(list.nulls(), field.is_nullable());
+                let validity = nulls(list.nulls(), field.is_nullable())?;
                 Ok(crate::arrays::ListArray::try_new(elements, offsets, validity)?.into_array())
             }
             DataType::LargeList(elem_field) => {
@@ -570,14 +541,14 @@ impl ArrowSession {
                 let elements = self
                     .from_arrow_array(ArrowArrayRef::clone(list.values()), elem_field.as_ref())?;
                 let offsets = list.offsets().clone().into_array();
-                let validity = nulls(list.nulls(), field.is_nullable());
+                let validity = nulls(list.nulls(), field.is_nullable())?;
                 Ok(crate::arrays::ListArray::try_new(elements, offsets, validity)?.into_array())
             }
             DataType::FixedSizeList(elem_field, list_size) => {
                 let fsl = array.as_fixed_size_list();
                 let elements =
                     self.from_arrow_array(ArrowArrayRef::clone(fsl.values()), elem_field.as_ref())?;
-                let validity = nulls(fsl.nulls(), field.is_nullable());
+                let validity = nulls(fsl.nulls(), field.is_nullable())?;
                 Ok(crate::arrays::FixedSizeListArray::try_new(
                     elements,
                     *list_size as u32,
@@ -592,7 +563,7 @@ impl ArrowSession {
                     .from_arrow_array(ArrowArrayRef::clone(list.values()), elem_field.as_ref())?;
                 let offsets = list.offsets().clone().into_array();
                 let sizes = list.sizes().clone().into_array();
-                let validity = nulls(list.nulls(), field.is_nullable());
+                let validity = nulls(list.nulls(), field.is_nullable())?;
                 Ok(
                     crate::arrays::ListViewArray::try_new(elements, offsets, sizes, validity)?
                         .into_array(),
@@ -604,7 +575,7 @@ impl ArrowSession {
                     .from_arrow_array(ArrowArrayRef::clone(list.values()), elem_field.as_ref())?;
                 let offsets = list.offsets().clone().into_array();
                 let sizes = list.sizes().clone().into_array();
-                let validity = nulls(list.nulls(), field.is_nullable());
+                let validity = nulls(list.nulls(), field.is_nullable())?;
                 Ok(
                     crate::arrays::ListViewArray::try_new(elements, offsets, sizes, validity)?
                         .into_array(),
diff --git a/vortex-array/src/buffer.rs b/vortex-array/src/buffer.rs
index 29f9d3582be..6c59140c9a6 100644
--- a/vortex-array/src/buffer.rs
+++ b/vortex-array/src/buffer.rs
@@ -19,7 +19,7 @@ use vortex_utils::dyn_traits::DynHash;
 
 use crate::ArrayEq;
 use crate::ArrayHash;
-use crate::Precision;
+use crate::EqMode;
 
 /// A handle to a buffer allocation.
 ///
@@ -249,6 +249,7 @@ impl BufferHandle {
     }
 
     /// Downcast this handle as a handle to a host-resident buffer, or `None`.
+    #[inline]
     pub fn as_host_opt(&self) -> Option<&ByteBuffer> {
         match &self.0 {
             Inner::Host(buffer) => Some(buffer),
@@ -266,6 +267,7 @@ impl BufferHandle {
 
     /// A version of [`as_host_opt`][Self::as_host_opt] that panics if the allocation is
     /// not a host allocation.
+    #[inline]
     pub fn as_host(&self) -> &ByteBuffer {
         self.as_host_opt().vortex_expect("expected host buffer")
     }
@@ -407,14 +409,14 @@ impl BufferHandle {
 
 impl ArrayHash for BufferHandle {
     // TODO(aduffy): implement for array hash
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, accuracy: EqMode) {
         match &self.0 {
-            Inner::Host(host) => host.array_hash(state, precision),
-            Inner::Device(dev) => match precision {
-                Precision::Ptr => {
+            Inner::Host(host) => host.array_hash(state, accuracy),
+            Inner::Device(dev) => match accuracy {
+                EqMode::Ptr => {
                     Arc::as_ptr(dev).hash(state);
                 }
-                Precision::Value => {
+                EqMode::Value => {
                     dev.hash(state);
                 }
             },
@@ -423,12 +425,12 @@ impl ArrayHash for BufferHandle {
 }
 
 impl ArrayEq for BufferHandle {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, accuracy: EqMode) -> bool {
         match (&self.0, &other.0) {
-            (Inner::Host(b), Inner::Host(b2)) => b.array_eq(b2, precision),
-            (Inner::Device(b), Inner::Device(b2)) => match precision {
-                Precision::Ptr => Arc::ptr_eq(b, b2),
-                Precision::Value => b.eq(b2),
+            (Inner::Host(b), Inner::Host(b2)) => b.array_eq(b2, accuracy),
+            (Inner::Device(b), Inner::Device(b2)) => match accuracy {
+                EqMode::Ptr => Arc::ptr_eq(b, b2),
+                EqMode::Value => b.eq(b2),
             },
             _ => false,
         }
diff --git a/vortex-array/src/builders/bool.rs b/vortex-array/src/builders/bool.rs
index c09d69a5acd..e829a58f6ec 100644
--- a/vortex-array/src/builders/bool.rs
+++ b/vortex-array/src/builders/bool.rs
@@ -121,7 +121,7 @@ impl ArrayBuilder for BoolBuilder {
 
         self.inner.append_buffer(&bool_array.to_bit_buffer());
         self.nulls.append_validity_mask(
-            bool_array
+            &bool_array
                 .as_ref()
                 .validity()
                 .vortex_expect("validity_mask")
@@ -139,8 +139,7 @@ impl ArrayBuilder for BoolBuilder {
     }
 
     unsafe fn set_validity_unchecked(&mut self, validity: Mask) {
-        self.nulls = LazyBitBufferBuilder::new(validity.len());
-        self.nulls.append_validity_mask(validity);
+        self.nulls = LazyBitBufferBuilder::from_validity_mask(validity);
     }
 
     fn finish(&mut self) -> ArrayRef {
@@ -210,11 +209,11 @@ mod tests {
         #[expect(deprecated)]
         let into_canon = chunk.to_bool();
 
-        assert!(
-            canon_into
-                .validity()?
-                .mask_eq(&into_canon.validity()?, &mut ctx)?
-        );
+        assert!(canon_into.validity()?.mask_eq(
+            &into_canon.validity()?,
+            canon_into.len(),
+            &mut ctx
+        )?);
         assert_eq!(canon_into.to_bit_buffer(), into_canon.to_bit_buffer());
         Ok(())
     }
diff --git a/vortex-array/src/builders/decimal.rs b/vortex-array/src/builders/decimal.rs
index c80f97d9ea2..f8d438d477b 100644
--- a/vortex-array/src/builders/decimal.rs
+++ b/vortex-array/src/builders/decimal.rs
@@ -207,7 +207,7 @@ impl ArrayBuilder for DecimalBuilder {
         });
 
         self.nulls.append_validity_mask(
-            decimal_array
+            &decimal_array
                 .as_ref()
                 .validity()
                 .vortex_expect("validity_mask")
@@ -225,8 +225,7 @@ impl ArrayBuilder for DecimalBuilder {
     }
 
     unsafe fn set_validity_unchecked(&mut self, validity: Mask) {
-        self.nulls = LazyBitBufferBuilder::new(validity.len());
-        self.nulls.append_validity_mask(validity);
+        self.nulls = LazyBitBufferBuilder::from_validity_mask(validity);
     }
 
     fn finish(&mut self) -> ArrayRef {
diff --git a/vortex-array/src/builders/extension.rs b/vortex-array/src/builders/extension.rs
index d947877e297..7e1da3b8f3e 100644
--- a/vortex-array/src/builders/extension.rs
+++ b/vortex-array/src/builders/extension.rs
@@ -54,6 +54,8 @@ impl ExtensionBuilder {
     }
 
     /// The [`ExtDType`] of this builder.
+    ///
+    /// [`ExtDType`]: crate::dtype::extension::ExtDType
     fn ext_dtype(&self) -> ExtDTypeRef {
         if let DType::Extension(ext_dtype) = &self.dtype {
             ext_dtype.clone()
diff --git a/vortex-array/src/builders/fixed_size_list.rs b/vortex-array/src/builders/fixed_size_list.rs
index 5937c37b041..7a3c3bb068a 100644
--- a/vortex-array/src/builders/fixed_size_list.rs
+++ b/vortex-array/src/builders/fixed_size_list.rs
@@ -246,7 +246,7 @@ impl ArrayBuilder for FixedSizeListBuilder {
 
         self.elements_builder.extend_from_array(fsl.elements());
         self.nulls.append_validity_mask(
-            array
+            &array
                 .validity()
                 .vortex_expect("validity_mask in extend_from_array_unchecked")
                 .execute_mask(array.len(), &mut LEGACY_SESSION.create_execution_ctx())
@@ -261,8 +261,7 @@ impl ArrayBuilder for FixedSizeListBuilder {
     }
 
     unsafe fn set_validity_unchecked(&mut self, validity: Mask) {
-        self.nulls = LazyBitBufferBuilder::new(validity.len());
-        self.nulls.append_validity_mask(validity);
+        self.nulls = LazyBitBufferBuilder::from_validity_mask(validity);
     }
 
     fn finish(&mut self) -> ArrayRef {
@@ -444,6 +443,7 @@ mod tests {
 
     #[test]
     fn test_nullable_lists_non_nullable_elements() {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let dtype: Arc<DType> = Arc::new(DType::Primitive(I32, NonNullable));
         let mut builder = FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 2, Nullable, 0);
 
@@ -475,21 +475,21 @@ mod tests {
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(0)
+                .execute_is_valid(0, &mut ctx)
                 .unwrap()
         );
         assert!(
             !fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(1)
+                .execute_is_valid(1, &mut ctx)
                 .unwrap()
         );
         assert!(
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(2)
+                .execute_is_valid(2, &mut ctx)
                 .unwrap()
         );
     }
@@ -562,6 +562,7 @@ mod tests {
 
     #[test]
     fn test_append_nulls() {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         // Elements must be nullable if we're going to append null lists
         let dtype: Arc<DType> = Arc::new(DType::Primitive(I32, Nullable));
         let mut builder = FixedSizeListBuilder::with_capacity(dtype, 2, Nullable, 0);
@@ -583,7 +584,7 @@ mod tests {
                 !fsl_array
                     .validity()
                     .vortex_expect("fixed-size-list validity should be derivable")
-                    .is_valid(i)
+                    .execute_is_valid(i, &mut ctx)
                     .unwrap()
             );
         }
@@ -591,6 +592,7 @@ mod tests {
 
     #[test]
     fn test_append_scalar_nulls() {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         // Elements must be nullable if we're going to append null lists
         let dtype: Arc<DType> = Arc::new(DType::Primitive(I32, Nullable));
         let mut builder = FixedSizeListBuilder::with_capacity(dtype, 2, Nullable, 0);
@@ -613,7 +615,7 @@ mod tests {
             !fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(0)
+                .execute_is_valid(0, &mut ctx)
                 .unwrap()
         );
     }
@@ -663,6 +665,7 @@ mod tests {
 
     #[test]
     fn test_extend_from_array() {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let dtype: Arc<DType> = Arc::new(I32.into());
 
         // Create a source array.
@@ -691,48 +694,49 @@ mod tests {
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(0)
+                .execute_is_valid(0, &mut ctx)
                 .unwrap()
         );
         assert!(
             !fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(1)
+                .execute_is_valid(1, &mut ctx)
                 .unwrap()
         );
         assert!(
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(2)
+                .execute_is_valid(2, &mut ctx)
                 .unwrap()
         );
         assert!(
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(3)
+                .execute_is_valid(3, &mut ctx)
                 .unwrap()
         );
         assert!(
             !fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(4)
+                .execute_is_valid(4, &mut ctx)
                 .unwrap()
         );
         assert!(
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(5)
+                .execute_is_valid(5, &mut ctx)
                 .unwrap()
         );
     }
 
     #[test]
     fn test_extend_degenerate_arrays() {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let dtype: Arc<DType> = Arc::new(I32.into());
 
         // Create degenerate source arrays (size = 0).
@@ -768,35 +772,35 @@ mod tests {
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(0)
+                .execute_is_valid(0, &mut ctx)
                 .unwrap()
         );
         assert!(
             !fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(1)
+                .execute_is_valid(1, &mut ctx)
                 .unwrap()
         );
         assert!(
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(2)
+                .execute_is_valid(2, &mut ctx)
                 .unwrap()
         );
         assert!(
             !fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(3)
+                .execute_is_valid(3, &mut ctx)
                 .unwrap()
         );
         assert!(
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(4)
+                .execute_is_valid(4, &mut ctx)
                 .unwrap()
         );
     }
@@ -837,6 +841,7 @@ mod tests {
 
     #[test]
     fn test_mixed_operations() {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         // Use nullable elements since we'll be appending nulls
         let dtype: Arc<DType> = Arc::new(DType::Primitive(I32, Nullable));
         let mut builder = FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 2, Nullable, 0);
@@ -880,48 +885,49 @@ mod tests {
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(0)
+                .execute_is_valid(0, &mut ctx)
                 .unwrap()
         ); // append_value
         assert!(
             !fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(1)
+                .execute_is_valid(1, &mut ctx)
                 .unwrap()
         ); // append_null
         assert!(
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(2)
+                .execute_is_valid(2, &mut ctx)
                 .unwrap()
         ); // append_zeros
         assert!(
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(3)
+                .execute_is_valid(3, &mut ctx)
                 .unwrap()
         ); // append_zeros
         assert!(
             !fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(4)
+                .execute_is_valid(4, &mut ctx)
                 .unwrap()
         ); // append_nulls
         assert!(
             fsl_array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(5)
+                .execute_is_valid(5, &mut ctx)
                 .unwrap()
         ); // extend_from_array
     }
 
     #[test]
     fn test_append_scalar() {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let dtype: Arc<DType> = Arc::new(I32.into());
         let mut builder = FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 2, Nullable, 10);
 
@@ -943,9 +949,7 @@ mod tests {
 
         // Check actual values using scalar_at.
 
-        let scalar0 = array
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        let scalar0 = array.execute_scalar(0, &mut ctx).unwrap();
         let list0 = scalar0.as_list();
         assert_eq!(list0.len(), 2);
         if let Some(list0_items) = list0.elements() {
@@ -953,9 +957,7 @@ mod tests {
             assert_eq!(list0_items[1].as_primitive().typed_value::<i32>(), Some(2));
         }
 
-        let scalar1 = array
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        let scalar1 = array.execute_scalar(1, &mut ctx).unwrap();
         let list1 = scalar1.as_list();
         assert_eq!(list1.len(), 2);
         if let Some(list1_items) = list1.elements() {
@@ -968,21 +970,21 @@ mod tests {
             array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(0)
+                .execute_is_valid(0, &mut ctx)
                 .unwrap()
         );
         assert!(
             array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(1)
+                .execute_is_valid(1, &mut ctx)
                 .unwrap()
         );
         assert!(
             !array
                 .validity()
                 .vortex_expect("fixed-size-list validity should be derivable")
-                .is_valid(2)
+                .execute_is_valid(2, &mut ctx)
                 .unwrap()
         );
 
diff --git a/vortex-array/src/builders/lazy_null_builder.rs b/vortex-array/src/builders/lazy_null_builder.rs
index 9ca4b28b484..24abe9ba17d 100644
--- a/vortex-array/src/builders/lazy_null_builder.rs
+++ b/vortex-array/src/builders/lazy_null_builder.rs
@@ -31,6 +31,42 @@ impl LazyBitBufferBuilder {
         }
     }
 
+    /// Creates a builder pre-populated from a validity mask, taking ownership of the mask's buffer
+    /// instead of copying it where possible.
+    ///
+    /// This is the counterpart to [`append_validity_mask`](Self::append_validity_mask) for callers
+    /// that want to *replace* the builder's contents with the mask rather than extend them: because
+    /// we own the mask, we can move its buffer in instead of copying it.
+    pub fn from_validity_mask(validity_mask: Mask) -> Self {
+        match validity_mask {
+            // An unmaterialized builder already represents `len` non-null values, so an all-valid
+            // mask stays lazy.
+            Mask::AllTrue(len) => Self {
+                inner: None,
+                len,
+                capacity: len,
+            },
+            Mask::AllFalse(len) => Self::from_buffer(BitBufferMut::new_unset(len)),
+            // Take ownership of the underlying buffer; `into_bit_buffer` and `try_into_mut` only
+            // copy when the buffer is shared, otherwise this is a move.
+            values @ Mask::Values(_) => Self::from_buffer(
+                values
+                    .into_bit_buffer()
+                    .try_into_mut()
+                    .unwrap_or_else(|buffer| BitBufferMut::copy_from(&buffer)),
+            ),
+        }
+    }
+
+    /// Creates a builder backed by an already-materialized buffer.
+    fn from_buffer(inner: BitBufferMut) -> Self {
+        Self {
+            inner: Some(inner),
+            len: 0,
+            capacity: 0,
+        }
+    }
+
     /// Appends `n` non-null values to the builder.
     #[inline]
     pub fn append_n_non_nulls(&mut self, n: usize) {
@@ -82,10 +118,13 @@ impl LazyBitBufferBuilder {
     }
 
     /// Appends values from a validity mask.
-    pub fn append_validity_mask(&mut self, validity_mask: Mask) {
+    ///
+    /// Takes the mask by reference: the `Mask::Values` case copies the underlying buffer into the
+    /// running null buffer, so there is nothing to gain from owning the mask.
+    pub fn append_validity_mask(&mut self, validity_mask: &Mask) {
         match validity_mask {
-            Mask::AllTrue(len) => self.append_n_non_nulls(len),
-            Mask::AllFalse(len) => self.append_n_nulls(len),
+            Mask::AllTrue(len) => self.append_n_non_nulls(*len),
+            Mask::AllFalse(len) => self.append_n_nulls(*len),
             Mask::Values(is_valid) => self.append_buffer(is_valid.bit_buffer()),
         }
     }
diff --git a/vortex-array/src/builders/list.rs b/vortex-array/src/builders/list.rs
index ae1bb20dfa9..ac97230daa8 100644
--- a/vortex-array/src/builders/list.rs
+++ b/vortex-array/src/builders/list.rs
@@ -226,7 +226,7 @@ impl<O: IntegerPType> ArrayBuilder for ListBuilder<O> {
 
         // Append validity information.
         self.nulls.append_validity_mask(
-            array
+            &array
                 .validity()
                 .vortex_expect("validity_mask in extend_from_array_unchecked")
                 .execute_mask(array.len(), &mut LEGACY_SESSION.create_execution_ctx())
@@ -300,8 +300,7 @@ impl<O: IntegerPType> ArrayBuilder for ListBuilder<O> {
     }
 
     unsafe fn set_validity_unchecked(&mut self, validity: Mask) {
-        self.nulls = LazyBitBufferBuilder::new(validity.len());
-        self.nulls.append_validity_mask(validity);
+        self.nulls = LazyBitBufferBuilder::from_validity_mask(validity);
     }
 
     fn finish(&mut self) -> ArrayRef {
@@ -491,6 +490,7 @@ mod tests {
                     &expected
                         .validity()
                         .vortex_expect("list validity should be derivable"),
+                    actual.len(),
                     &mut ctx,
                 )
                 .unwrap(),
@@ -580,11 +580,11 @@ mod tests {
         let array = builder.finish_into_list();
         assert_eq!(array.len(), 3);
 
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+
         // Check actual values using scalar_at.
 
-        let scalar0 = array
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        let scalar0 = array.execute_scalar(0, &mut ctx).unwrap();
         let list0 = scalar0.as_list();
         assert_eq!(list0.len(), 2);
         if let Some(list0_items) = list0.elements() {
@@ -592,9 +592,7 @@ mod tests {
             assert_eq!(list0_items[1].as_primitive().typed_value::<i32>(), Some(2));
         }
 
-        let scalar1 = array
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        let scalar1 = array.execute_scalar(1, &mut ctx).unwrap();
         let list1 = scalar1.as_list();
         assert_eq!(list1.len(), 3);
         if let Some(list1_items) = list1.elements() {
@@ -603,9 +601,7 @@ mod tests {
             assert_eq!(list1_items[2].as_primitive().typed_value::<i32>(), Some(5));
         }
 
-        let scalar2 = array
-            .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap();
+        let scalar2 = array.execute_scalar(2, &mut ctx).unwrap();
         let list2 = scalar2.as_list();
         assert!(list2.is_null()); // This should be null.
 
@@ -614,21 +610,21 @@ mod tests {
             array
                 .validity()
                 .vortex_expect("list validity should be derivable")
-                .is_valid(0)
+                .execute_is_valid(0, &mut ctx)
                 .unwrap()
         );
         assert!(
             array
                 .validity()
                 .vortex_expect("list validity should be derivable")
-                .is_valid(1)
+                .execute_is_valid(1, &mut ctx)
                 .unwrap()
         );
         assert!(
             !array
                 .validity()
                 .vortex_expect("list validity should be derivable")
-                .is_valid(2)
+                .execute_is_valid(2, &mut ctx)
                 .unwrap()
         );
 
diff --git a/vortex-array/src/builders/listview.rs b/vortex-array/src/builders/listview.rs
index 3c7bb8e8885..4c350f1888d 100644
--- a/vortex-array/src/builders/listview.rs
+++ b/vortex-array/src/builders/listview.rs
@@ -21,8 +21,6 @@ use vortex_mask::Mask;
 use crate::ArrayRef;
 use crate::Canonical;
 use crate::LEGACY_SESSION;
-#[expect(deprecated)]
-use crate::ToCanonical as _;
 use crate::VortexSessionExecute;
 use crate::array::IntoArray;
 use crate::arrays::ListViewArray;
@@ -294,8 +292,16 @@ impl<O: IntegerPType, S: IntegerPType> ArrayBuilder for ListViewBuilder<O, S> {
     }
 
     unsafe fn extend_from_array_unchecked(&mut self, array: &ArrayRef) {
-        #[expect(deprecated)]
-        let listview = array.to_listview();
+        // TODO: The `ArrayBuilder` trait does not thread an `ExecutionCtx` through its extend
+        // methods, so we are forced to mint a fresh `LEGACY_SESSION` context here on every call
+        // (which for chunked input means once per chunk). Once the trait carries a `&mut
+        // ExecutionCtx`, the caller's session should be reused instead.
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+
+        let listview = array
+            .clone()
+            .execute::<ListViewArray>(&mut ctx)
+            .vortex_expect("failed to execute array into ListViewArray in extend_from_array");
         if listview.is_empty() {
             return;
         }
@@ -303,15 +309,15 @@ impl<O: IntegerPType, S: IntegerPType> ArrayBuilder for ListViewBuilder<O, S> {
         // Normalize to an exact zero-copy-to-list layout and then bulk append. This avoids the
         // very expensive scalar_at-per-list path for overlapping / out-of-order list views.
         let listview = listview
-            .rebuild(ListViewRebuildMode::MakeExact)
+            .rebuild(ListViewRebuildMode::MakeExact, &mut ctx)
             .vortex_expect("ListViewArray::rebuild(MakeExact) failed in extend_from_array");
         debug_assert!(listview.is_zero_copy_to_list());
 
         self.nulls.append_validity_mask(
-            array
+            &array
                 .validity()
                 .vortex_expect("validity_mask in extend_from_array_unchecked")
-                .execute_mask(array.len(), &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_mask(array.len(), &mut ctx)
                 .vortex_expect("Failed to compute validity mask"),
         );
 
@@ -343,8 +349,11 @@ impl<O: IntegerPType, S: IntegerPType> ArrayBuilder for ListViewBuilder<O, S> {
         let uninit_range = self.offsets_builder.uninit_range(extend_length);
 
         // This should be cheap because we didn't compress after rebuilding.
-        #[expect(deprecated)]
-        let new_offsets = listview.offsets().to_primitive();
+        let new_offsets = listview
+            .offsets()
+            .clone()
+            .execute::<PrimitiveArray>(&mut ctx)
+            .vortex_expect("failed to execute list view offsets into a PrimitiveArray");
 
         match_each_integer_ptype!(new_offsets.ptype(), |A| {
             adjust_and_extend_offsets::<O, A>(
@@ -364,8 +373,7 @@ impl<O: IntegerPType, S: IntegerPType> ArrayBuilder for ListViewBuilder<O, S> {
     }
 
     unsafe fn set_validity_unchecked(&mut self, validity: Mask) {
-        self.nulls = LazyBitBufferBuilder::new(validity.len());
-        self.nulls.append_validity_mask(validity);
+        self.nulls = LazyBitBufferBuilder::from_validity_mask(validity);
     }
 
     fn finish(&mut self) -> ArrayRef {
@@ -426,6 +434,8 @@ mod tests {
 
     use super::ListViewBuilder;
     use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
     use crate::arrays::ListArray;
     use crate::arrays::ListViewArray;
     use crate::arrays::listview::ListViewArrayExt;
@@ -450,6 +460,7 @@ mod tests {
 
     #[test]
     fn test_basic_append_and_nulls() {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let dtype: Arc<DType> = Arc::new(I32.into());
         let mut builder =
             ListViewBuilder::<u32, u32>::with_capacity(Arc::clone(&dtype), Nullable, 0, 0);
@@ -498,7 +509,7 @@ mod tests {
             !listview
                 .validity()
                 .vortex_expect("listview validity should be derivable")
-                .is_valid(2)
+                .execute_is_valid(2, &mut ctx)
                 .unwrap()
         );
 
@@ -580,6 +591,7 @@ mod tests {
 
     #[test]
     fn test_builder_trait_methods() {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let dtype: Arc<DType> = Arc::new(I32.into());
         let mut builder =
             ListViewBuilder::<u32, u32>::with_capacity(Arc::clone(&dtype), Nullable, 0, 0);
@@ -611,14 +623,14 @@ mod tests {
             !listview
                 .validity()
                 .vortex_expect("listview validity should be derivable")
-                .is_valid(2)
+                .execute_is_valid(2, &mut ctx)
                 .unwrap()
         );
         assert!(
             !listview
                 .validity()
                 .vortex_expect("listview validity should be derivable")
-                .is_valid(3)
+                .execute_is_valid(3, &mut ctx)
                 .unwrap()
         );
 
@@ -631,6 +643,7 @@ mod tests {
 
     #[test]
     fn test_extend_from_array() {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let dtype: Arc<DType> = Arc::new(I32.into());
 
         // Create a source ListArray.
@@ -680,7 +693,7 @@ mod tests {
             !listview
                 .validity()
                 .vortex_expect("listview validity should be derivable")
-                .is_valid(2)
+                .execute_is_valid(2, &mut ctx)
                 .unwrap()
         );
 
@@ -693,6 +706,7 @@ mod tests {
 
     #[test]
     fn test_extend_from_array_overlapping_listview() {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let dtype: Arc<DType> = Arc::new(I32.into());
 
         // Non-ZCTL source:
@@ -725,7 +739,7 @@ mod tests {
             !listview
                 .validity()
                 .vortex_expect("listview validity should be derivable")
-                .is_valid(1)
+                .execute_is_valid(1, &mut ctx)
                 .unwrap()
         );
         assert_eq!(listview.list_elements_at(1).unwrap().len(), 0);
diff --git a/vortex-array/src/builders/primitive.rs b/vortex-array/src/builders/primitive.rs
index 59381fc602f..c4b5abfb083 100644
--- a/vortex-array/src/builders/primitive.rs
+++ b/vortex-array/src/builders/primitive.rs
@@ -127,7 +127,7 @@ impl<T: NativePType> PrimitiveBuilder<T> {
     }
 
     /// Extends the primitive array with an iterator.
-    pub fn extend_with_iterator(&mut self, iter: impl IntoIterator<Item = T>, mask: Mask) {
+    pub fn extend_with_iterator(&mut self, iter: impl IntoIterator<Item = T>, mask: &Mask) {
         self.values.extend(iter);
         self.nulls.append_validity_mask(mask);
     }
@@ -190,7 +190,7 @@ impl<T: NativePType> ArrayBuilder for PrimitiveBuilder<T> {
 
         self.values.extend_from_slice(array.as_slice::<T>());
         self.nulls.append_validity_mask(
-            array
+            &array
                 .as_ref()
                 .validity()
                 .vortex_expect("validity_mask")
@@ -208,8 +208,7 @@ impl<T: NativePType> ArrayBuilder for PrimitiveBuilder<T> {
     }
 
     unsafe fn set_validity_unchecked(&mut self, validity: Mask) {
-        self.nulls = LazyBitBufferBuilder::new(validity.len());
-        self.nulls.append_validity_mask(validity);
+        self.nulls = LazyBitBufferBuilder::from_validity_mask(validity);
     }
 
     fn finish(&mut self) -> ArrayRef {
@@ -271,7 +270,7 @@ impl<T> UninitRange<'_, T> {
     /// - The caller must ensure that they safely initialize `mask.len()` primitive values via
     ///   [`UninitRange::copy_from_slice`].
     /// - The caller must also ensure that they only call this method once.
-    pub unsafe fn append_mask(&mut self, mask: Mask) {
+    pub unsafe fn append_mask(&mut self, mask: &Mask) {
         assert_eq!(
             mask.len(),
             self.len,
@@ -426,7 +425,7 @@ mod tests {
 
         // SAFETY: We're about to initialize the values.
         unsafe {
-            range.append_mask(mask);
+            range.append_mask(&mask);
         }
 
         // Initialize the values.
@@ -476,7 +475,7 @@ mod tests {
 
         // SAFETY: This is expected to panic due to length mismatch.
         unsafe {
-            range.append_mask(wrong_mask);
+            range.append_mask(&wrong_mask);
         }
     }
 
@@ -522,7 +521,7 @@ mod tests {
         let initial_mask = Mask::from_iter([false, false, false]);
         // SAFETY: We're about to initialize the values.
         unsafe {
-            range.append_mask(initial_mask);
+            range.append_mask(&initial_mask);
         }
 
         // Now we can use set_bit to modify individual bits with relative indexing.
@@ -623,7 +622,7 @@ mod tests {
         let mask = Mask::from_iter([true, true, false]);
         // SAFETY: We're about to initialize the matching number of values.
         unsafe {
-            range.append_mask(mask);
+            range.append_mask(&mask);
         }
 
         // Initialize all values.
@@ -671,25 +670,26 @@ mod tests {
         // values[2] might be any value since it's null.
 
         // Check validity - first two should be valid, third should be null.
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
         assert!(
             array
                 .validity()
                 .vortex_expect("primitive validity should be derivable")
-                .is_valid(0)
+                .execute_is_valid(0, &mut ctx)
                 .unwrap()
         );
         assert!(
             array
                 .validity()
                 .vortex_expect("primitive validity should be derivable")
-                .is_valid(1)
+                .execute_is_valid(1, &mut ctx)
                 .unwrap()
         );
         assert!(
             !array
                 .validity()
                 .vortex_expect("primitive validity should be derivable")
-                .is_valid(2)
+                .execute_is_valid(2, &mut ctx)
                 .unwrap()
         );
 
diff --git a/vortex-array/src/builders/struct_.rs b/vortex-array/src/builders/struct_.rs
index b7c737b3f1c..d396cf186a0 100644
--- a/vortex-array/src/builders/struct_.rs
+++ b/vortex-array/src/builders/struct_.rs
@@ -180,7 +180,7 @@ impl ArrayBuilder for StructBuilder {
         }
 
         self.nulls.append_validity_mask(
-            array
+            &array
                 .validity()
                 .vortex_expect("validity_mask")
                 .execute_mask(array.len(), &mut LEGACY_SESSION.create_execution_ctx())
@@ -196,8 +196,7 @@ impl ArrayBuilder for StructBuilder {
     }
 
     unsafe fn set_validity_unchecked(&mut self, validity: Mask) {
-        self.nulls = LazyBitBufferBuilder::new(validity.len());
-        self.nulls.append_validity_mask(validity);
+        self.nulls = LazyBitBufferBuilder::from_validity_mask(validity);
     }
 
     fn finish(&mut self) -> ArrayRef {
diff --git a/vortex-array/src/builders/tests.rs b/vortex-array/src/builders/tests.rs
index 53b010597cc..b725a4636b5 100644
--- a/vortex-array/src/builders/tests.rs
+++ b/vortex-array/src/builders/tests.rs
@@ -5,6 +5,8 @@ use std::sync::Arc;
 
 use rstest::rstest;
 use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_mask::Mask;
 
 use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
@@ -820,3 +822,67 @@ fn test_append_scalar_repeated_same_instance() {
         );
     }
 }
+
+/// Test that `set_validity` correctly overrides a builder's validity across all mask variants.
+///
+/// `set_validity` moves the mask's buffer into the builder rather than copying it, so the
+/// `sliced_offset` case is important: slicing a `Mask::Values` at a non-byte-aligned boundary
+/// yields a buffer with a non-zero bit offset, which the move path must preserve.
+#[rstest]
+#[case::all_true(Mask::new_true(8), vec![true; 8])]
+#[case::all_false(Mask::new_false(8), vec![false; 8])]
+#[case::values(
+    Mask::from_iter([true, false, true, true, false, false, true, false]),
+    vec![true, false, true, true, false, false, true, false]
+)]
+#[case::sliced_offset(
+    Mask::from_iter([
+        false, false, false, // dropped by the slice
+        true, false, true, true, false, false, true, false, // kept: indices 3..11
+        true, true, true, true, true, // dropped by the slice
+    ])
+    .slice(3..11),
+    vec![true, false, true, true, false, false, true, false]
+)]
+fn test_set_validity_overrides_validity(
+    #[case] mask: Mask,
+    #[case] expected: Vec<bool>,
+) -> VortexResult<()> {
+    let dtype = DType::Primitive(PType::I32, Nullability::Nullable);
+    let mut builder = builder_with_capacity(&dtype, mask.len());
+    builder.append_zeros(mask.len());
+
+    builder.set_validity(mask);
+
+    let validity = builder.finish().validity()?;
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    for (i, &valid) in expected.iter().enumerate() {
+        assert_eq!(
+            validity.execute_is_valid(i, &mut ctx)?,
+            valid,
+            "validity mismatch at index {i}"
+        );
+    }
+    Ok(())
+}
+
+/// Test that `set_validity` is a no-op on a non-nullable builder.
+#[test]
+fn test_set_validity_noop_when_non_nullable() -> VortexResult<()> {
+    let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
+    let mut builder = builder_with_capacity(&dtype, 4);
+    builder.append_zeros(4);
+
+    // Providing an all-false mask must not make the non-nullable array invalid.
+    builder.set_validity(Mask::new_false(4));
+
+    let validity = builder.finish().validity()?;
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    for i in 0..4 {
+        assert!(
+            validity.execute_is_valid(i, &mut ctx)?,
+            "index {i} should remain valid"
+        );
+    }
+    Ok(())
+}
diff --git a/vortex-array/src/builders/varbinview.rs b/vortex-array/src/builders/varbinview.rs
index 9150e8e70e1..392bef59997 100644
--- a/vortex-array/src/builders/varbinview.rs
+++ b/vortex-array/src/builders/varbinview.rs
@@ -206,7 +206,7 @@ impl VarBinViewBuilder {
             "Some buffers already exist",
         );
         self.views_builder.extend_trusted(views.iter().copied());
-        self.push_only_validity_mask(validity_mask);
+        self.push_only_validity_mask(&validity_mask);
 
         debug_assert_eq!(self.nulls.len(), self.views_builder.len())
     }
@@ -236,7 +236,7 @@ impl VarBinViewBuilder {
     }
 
     // Pushes a validity mask into the builder not affecting the views or buffers
-    fn push_only_validity_mask(&mut self, validity_mask: Mask) {
+    fn push_only_validity_mask(&mut self, validity_mask: &Mask) {
         self.nulls.append_validity_mask(validity_mask);
     }
 }
@@ -299,17 +299,13 @@ impl ArrayBuilder for VarBinViewBuilder {
         let array = array.to_varbinview();
         self.flush_in_progress();
 
-        self.push_only_validity_mask(
-            array
-                .as_ref()
-                .validity()
-                .vortex_expect("validity_mask")
-                .execute_mask(
-                    array.as_ref().len(),
-                    &mut LEGACY_SESSION.create_execution_ctx(),
-                )
-                .vortex_expect("Failed to compute validity mask"),
-        );
+        let mask = array
+            .validity()
+            .vortex_expect("validity_mask")
+            .execute_mask(array.len(), &mut LEGACY_SESSION.create_execution_ctx())
+            .vortex_expect("Failed to compute validity mask");
+
+        self.push_only_validity_mask(&mask);
 
         let view_adjustment =
             self.completed
@@ -325,41 +321,30 @@ impl ArrayBuilder for VarBinViewBuilder {
                     .iter()
                     .map(|view| adjustment.adjust_view(view)),
             ),
-            ViewAdjustment::Rewriting(adjustment) => {
-                match array
-                    .as_ref()
-                    .validity()
-                    .vortex_expect("validity_mask")
-                    .execute_mask(
-                        array.as_ref().len(),
-                        &mut LEGACY_SESSION.create_execution_ctx(),
-                    )
-                    .vortex_expect("Failed to compute validity mask")
-                {
-                    Mask::AllTrue(_) => {
-                        for (idx, &view) in array.views().iter().enumerate() {
-                            let new_view = self.push_view(view, &adjustment, &array, idx);
-                            self.views_builder.push(new_view);
-                        }
-                    }
-                    Mask::AllFalse(_) => {
-                        self.views_builder
-                            .push_n(BinaryView::empty_view(), array.len());
+            ViewAdjustment::Rewriting(adjustment) => match mask {
+                Mask::AllTrue(_) => {
+                    for (idx, &view) in array.views().iter().enumerate() {
+                        let new_view = self.push_view(view, &adjustment, &array, idx);
+                        self.views_builder.push(new_view);
                     }
-                    Mask::Values(v) => {
-                        for (idx, (&view, is_valid)) in
-                            array.views().iter().zip(v.bit_buffer().iter()).enumerate()
-                        {
-                            let new_view = if !is_valid {
-                                BinaryView::empty_view()
-                            } else {
-                                self.push_view(view, &adjustment, &array, idx)
-                            };
-                            self.views_builder.push(new_view);
-                        }
+                }
+                Mask::AllFalse(_) => {
+                    self.views_builder
+                        .push_n(BinaryView::empty_view(), array.len());
+                }
+                Mask::Values(v) => {
+                    for (idx, (&view, is_valid)) in
+                        array.views().iter().zip(v.bit_buffer().iter()).enumerate()
+                    {
+                        let new_view = if !is_valid {
+                            BinaryView::empty_view()
+                        } else {
+                            self.push_view(view, &adjustment, &array, idx)
+                        };
+                        self.views_builder.push(new_view);
                     }
                 }
-            }
+            },
         }
     }
 
@@ -369,8 +354,7 @@ impl ArrayBuilder for VarBinViewBuilder {
     }
 
     unsafe fn set_validity_unchecked(&mut self, validity: Mask) {
-        self.nulls = LazyBitBufferBuilder::new(validity.len());
-        self.nulls.append_validity_mask(validity);
+        self.nulls = LazyBitBufferBuilder::from_validity_mask(validity);
     }
 
     fn finish(&mut self) -> ArrayRef {
@@ -383,6 +367,7 @@ impl ArrayBuilder for VarBinViewBuilder {
 }
 
 impl VarBinViewBuilder {
+    #[inline]
     fn push_view(
         &mut self,
         view: BinaryView,
@@ -626,8 +611,8 @@ impl BuffersWithOffsets {
                 buffers: Arc::from(
                     array
                         .data_buffers()
-                        .to_vec()
-                        .into_iter()
+                        .iter()
+                        .cloned()
                         .map(|b| b.unwrap_host())
                         .collect_vec(),
                 ),
@@ -774,6 +759,7 @@ enum PrecomputedViewAdjustment {
 }
 
 impl PrecomputedViewAdjustment {
+    #[inline]
     fn adjust_view(&self, view: &BinaryView) -> BinaryView {
         if view.is_inlined() {
             return *view;
@@ -831,6 +817,7 @@ struct RewritingViewAdjustment {
 impl RewritingViewAdjustment {
     /// Can return None if this view can't be adjusted, because there is no precomputed lookup
     /// for the current buffer.
+    #[inline]
     fn adjust_view(&self, view: &BinaryView) -> Option<BinaryView> {
         if view.is_inlined() {
             return Some(*view);
diff --git a/vortex-array/src/builtins.rs b/vortex-array/src/builtins.rs
index dcbe934097e..d3b27bb8753 100644
--- a/vortex-array/src/builtins.rs
+++ b/vortex-array/src/builtins.rs
@@ -14,6 +14,7 @@ use vortex_error::VortexResult;
 use crate::ArrayRef;
 use crate::IntoArray;
 use crate::arrays::ConstantArray;
+use crate::arrays::InterleaveArray;
 use crate::arrays::scalar_fn::ScalarFnFactoryExt;
 use crate::dtype::DType;
 use crate::dtype::FieldName;
@@ -67,6 +68,8 @@ pub trait ExprBuiltins: Sized {
     /// Conditional selection: `result[i] = if mask[i] then if_true[i] else if_false[i]`.
     fn zip(&self, if_true: Expression, if_false: Expression) -> VortexResult<Expression>;
 
+    // TODO(joe): add an `interleave` expression builtin mirroring `ArrayBuiltins::interleave`.
+
     /// Apply a binary operator to this expression and another.
     fn binary(&self, rhs: Expression, op: Operator) -> VortexResult<Expression>;
 }
@@ -140,6 +143,16 @@ pub trait ArrayBuiltins: Sized {
     /// Conditional selection: `result[i] = if mask[i] then if_true[i] else if_false[i]`.
     fn zip(&self, if_true: ArrayRef, if_false: ArrayRef) -> VortexResult<ArrayRef>;
 
+    /// Random-access gather by `(array_index, row_index)`: output row `i` is taken from
+    /// `values[array_indices[i]][row_indices[i]]`, where `self` is the (non-nullable)
+    /// `array_indices` selector and `row_indices` names the position within the selected value.
+    /// See [`InterleaveArray`].
+    fn interleave(
+        &self,
+        values: impl IntoIterator<Item = ArrayRef>,
+        row_indices: ArrayRef,
+    ) -> VortexResult<ArrayRef>;
+
     /// Check if a list contains a value.
     fn list_contains(&self, value: ArrayRef) -> VortexResult<ArrayRef>;
 
@@ -213,6 +226,17 @@ impl ArrayBuiltins for ArrayRef {
         Zip.try_new_array(self.len(), EmptyOptions, [if_true, if_false, self.clone()])
     }
 
+    fn interleave(
+        &self,
+        values: impl IntoIterator<Item = ArrayRef>,
+        row_indices: ArrayRef,
+    ) -> VortexResult<ArrayRef> {
+        Ok(
+            InterleaveArray::try_new(values.into_iter().collect(), self.clone(), row_indices)?
+                .into_array(),
+        )
+    }
+
     fn list_contains(&self, value: ArrayRef) -> VortexResult<ArrayRef> {
         ListContains
             .try_new_array(self.len(), EmptyOptions, [self.clone(), value])?
diff --git a/vortex-array/src/canonical.rs b/vortex-array/src/canonical.rs
index b1773d453f2..3c07650b2ef 100644
--- a/vortex-array/src/canonical.rs
+++ b/vortex-array/src/canonical.rs
@@ -258,11 +258,11 @@ impl Canonical {
     ///
     /// This operation is very expensive and can result in things like allocations, full-scans
     /// and copy operations.
-    pub fn compact(&self) -> VortexResult<Canonical> {
+    pub fn compact(&self, ctx: &mut ExecutionCtx) -> VortexResult<Canonical> {
         match self {
             Canonical::VarBinView(array) => Ok(Canonical::VarBinView(array.compact_buffers()?)),
             Canonical::List(array) => Ok(Canonical::List(
-                array.rebuild(ListViewRebuildMode::TrimElements)?,
+                array.rebuild(ListViewRebuildMode::TrimElements, ctx)?,
             )),
             _ => Ok(self.clone()),
         }
@@ -563,9 +563,14 @@ impl Executable for CanonicalValidity {
             Canonical::Bool(b) => {
                 let validity = child_to_validity(b.slots()[0].as_ref(), b.dtype().nullability());
                 let len = b.len();
-                let BoolDataParts { bits, offset, len } = b.into_data().into_parts(len);
+                let BoolDataParts { bits, meta } = b.into_data().into_parts(len);
                 Ok(CanonicalValidity(Canonical::Bool(
-                    BoolArray::try_new_from_handle(bits, offset, len, validity.execute(ctx)?)?,
+                    BoolArray::try_new_from_handle(
+                        bits,
+                        meta.offset(),
+                        meta.len(),
+                        validity.execute(ctx)?,
+                    )?,
                 )))
             }
             Canonical::Primitive(p) => {
@@ -713,9 +718,14 @@ impl Executable for RecursiveCanonical {
             Canonical::Bool(b) => {
                 let validity = child_to_validity(b.slots()[0].as_ref(), b.dtype().nullability());
                 let len = b.len();
-                let BoolDataParts { bits, offset, len } = b.into_data().into_parts(len);
+                let BoolDataParts { bits, meta } = b.into_data().into_parts(len);
                 Ok(RecursiveCanonical(Canonical::Bool(
-                    BoolArray::try_new_from_handle(bits, offset, len, validity.execute(ctx)?)?,
+                    BoolArray::try_new_from_handle(
+                        bits,
+                        meta.offset(),
+                        meta.len(),
+                        validity.execute(ctx)?,
+                    )?,
                 )))
             }
             Canonical::Primitive(p) => {
@@ -1062,6 +1072,7 @@ pub struct AnyCanonical;
 impl Matcher for AnyCanonical {
     type Match<'a> = CanonicalView<'a>;
 
+    #[inline]
     fn matches(array: &ArrayRef) -> bool {
         array.is::<Null>()
             || array.is::<Bool>()
@@ -1075,6 +1086,7 @@ impl Matcher for AnyCanonical {
             || array.is::<Extension>()
     }
 
+    #[inline]
     fn try_match(array: &ArrayRef) -> Option<Self::Match<'_>> {
         if let Some(a) = array.as_opt::<Null>() {
             Some(CanonicalView::Null(a))
@@ -1103,6 +1115,7 @@ impl Matcher for AnyCanonical {
 #[cfg(test)]
 mod test {
     use std::sync::Arc;
+    use std::sync::LazyLock;
 
     use arrow_array::Array as ArrowArray;
     use arrow_array::ArrayRef as ArrowArrayRef;
@@ -1122,12 +1135,12 @@ mod test {
     use vortex_buffer::buffer;
     use vortex_error::VortexResult;
     use vortex_error::vortex_err;
+    use vortex_session::VortexSession;
 
     use crate::ArrayRef;
     use crate::Canonical;
     use crate::CanonicalValidity;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::arrays::Constant;
     use crate::arrays::ConstantArray;
@@ -1142,6 +1155,11 @@ mod test {
     use crate::canonical::StructArray;
     use crate::dtype::Nullability;
     use crate::scalar::Scalar;
+    use crate::session::ArraySession;
+
+    /// A shared session for these canonical tests, used to create execution contexts.
+    static SESSION: LazyLock<VortexSession> =
+        LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
 
     fn variant_core_storage(len: usize) -> ArrayRef {
         ConstantArray::new(
@@ -1163,7 +1181,7 @@ mod test {
         let outer_variant =
             VariantArray::try_new(variant_core_storage(len), Some(inner_variant.into_array()))?;
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let Canonical::Variant(canonical) = outer_variant
             .into_array()
             .execute::<CanonicalValidity>(&mut ctx)?
@@ -1190,7 +1208,7 @@ mod test {
 
     #[test]
     fn test_canonicalize_nested_struct() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         // Create a struct array with multiple internal components.
         let nested_struct_array = StructArray::from_fields(&[
             ("a", buffer![1u64].into_array()),
@@ -1210,7 +1228,7 @@ mod test {
         ])
         .unwrap();
 
-        let arrow_struct = LEGACY_SESSION
+        let arrow_struct = SESSION
             .arrow()
             .execute_arrow(nested_struct_array.into_array(), None, &mut ctx)
             .unwrap()
@@ -1247,7 +1265,7 @@ mod test {
 
     #[test]
     fn roundtrip_struct() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let mut nulls = NullBufferBuilder::new(6);
         nulls.append_n_non_nulls(4);
         nulls.append_null();
@@ -1280,7 +1298,7 @@ mod test {
         );
 
         let vortex_struct = ArrayRef::from_arrow(&arrow_struct, true).unwrap();
-        let vortex_struct = LEGACY_SESSION
+        let vortex_struct = SESSION
             .arrow()
             .execute_arrow(vortex_struct, None, &mut ctx)
             .unwrap();
@@ -1289,7 +1307,7 @@ mod test {
 
     #[test]
     fn roundtrip_list() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let names = Arc::new(StringArray::from_iter(vec![
             Some("Joseph"),
             Some("Angela"),
@@ -1307,7 +1325,7 @@ mod test {
 
         let vortex_list = ArrayRef::from_arrow(&arrow_list, true).unwrap();
 
-        let rt_arrow_list = LEGACY_SESSION
+        let rt_arrow_list = SESSION
             .arrow()
             .execute_arrow(vortex_list, Some(&list_field), &mut ctx)
             .unwrap();
diff --git a/vortex-array/src/display/mod.rs b/vortex-array/src/display/mod.rs
index 3d121cf80b9..0134a28558c 100644
--- a/vortex-array/src/display/mod.rs
+++ b/vortex-array/src/display/mod.rs
@@ -579,19 +579,22 @@ impl ArrayRef {
             }
             #[cfg(feature = "table-display")]
             DisplayOptions::TableDisplay => {
+                use vortex_mask::Mask;
+
+                use crate::arrays::StructArray;
                 use crate::arrays::struct_::StructArrayExt;
-                #[expect(deprecated)]
-                use crate::canonical::ToCanonical as _;
                 use crate::dtype::DType;
 
                 let mut builder = tabled::builder::Builder::default();
+                // Reuse a single execution context across all per-row accesses below.
+                let mut ctx = LEGACY_SESSION.create_execution_ctx();
 
                 // Special logic for struct arrays.
                 let DType::Struct(sf, _) = self.dtype() else {
                     // For non-struct arrays, simply display a single column table without header.
                     for row_idx in 0..self.len() {
                         let value = self
-                            .execute_scalar(row_idx, &mut LEGACY_SESSION.create_execution_ctx())
+                            .execute_scalar(row_idx, &mut ctx)
                             .map_or_else(|e| format!("<error: {e}>"), |s| s.to_string());
                         builder.push_record([value]);
                     }
@@ -602,22 +605,27 @@ impl ArrayRef {
                     return write!(f, "{table}");
                 };
 
-                #[expect(deprecated)]
-                let struct_ = self.to_struct();
+                let struct_ = match self.clone().execute::<StructArray>(&mut ctx) {
+                    Ok(struct_) => struct_,
+                    Err(e) => return write!(f, "<error: {e}>"),
+                };
                 builder.push_record(sf.names().iter().map(|name| name.to_string()));
 
+                // Resolve validity to a mask once instead of probing it per row.
+                let validity = self
+                    .validity()
+                    .and_then(|v| v.execute_mask(self.len(), &mut ctx))
+                    .unwrap_or_else(|_| Mask::new_false(self.len()));
+
                 for row_idx in 0..self.len() {
-                    if !self
-                        .is_valid(row_idx, &mut LEGACY_SESSION.create_execution_ctx())
-                        .unwrap_or(false)
-                    {
+                    if !validity.value(row_idx) {
                         let null_row = vec!["null".to_string(); sf.names().len()];
                         builder.push_record(null_row);
                     } else {
-                        let mut row = Vec::new();
+                        let mut row = Vec::with_capacity(struct_.struct_fields().nfields());
                         for field_array in StructArrayExt::iter_unmasked_fields(&struct_) {
                             let value = field_array
-                                .execute_scalar(row_idx, &mut LEGACY_SESSION.create_execution_ctx())
+                                .execute_scalar(row_idx, &mut ctx)
                                 .map_or_else(|e| format!("<error: {e}>"), |s| s.to_string());
                             row.push(value);
                         }
@@ -634,10 +642,7 @@ impl ArrayRef {
                 }
 
                 for row_idx in 0..self.len() {
-                    if !self
-                        .is_valid(row_idx, &mut LEGACY_SESSION.create_execution_ctx())
-                        .unwrap_or(false)
-                    {
+                    if !validity.value(row_idx) {
                         table.modify(
                             (1 + row_idx, 0),
                             tabled::settings::Span::column(sf.names().len() as isize),
diff --git a/vortex-array/src/dtype/arrow.rs b/vortex-array/src/dtype/arrow.rs
index b107746e3e9..e03cf673c21 100644
--- a/vortex-array/src/dtype/arrow.rs
+++ b/vortex-array/src/dtype/arrow.rs
@@ -458,6 +458,18 @@ mod test {
         );
     }
 
+    #[rstest]
+    #[case(1, DataType::Decimal128(1, 0))]
+    #[case(38, DataType::Decimal128(38, 0))]
+    #[case(39, DataType::Decimal256(39, 0))]
+    #[case(76, DataType::Decimal256(76, 0))]
+    fn test_decimal_dtype_to_arrow(#[case] precision: u8, #[case] expected: DataType) {
+        use crate::dtype::DecimalDType;
+
+        let dtype = DType::Decimal(DecimalDType::new(precision, 0), Nullability::NonNullable);
+        assert_eq!(dtype.to_arrow_dtype().unwrap(), expected);
+    }
+
     #[test]
     fn test_variant_dtype_to_arrow_dtype_errors() {
         let err = DType::Variant(Nullability::NonNullable)
diff --git a/vortex-array/src/dtype/field.rs b/vortex-array/src/dtype/field.rs
index 45ddb70c9a7..84f631b5074 100644
--- a/vortex-array/src/dtype/field.rs
+++ b/vortex-array/src/dtype/field.rs
@@ -239,18 +239,56 @@ impl Display for FieldPath {
 }
 
 #[derive(Default, Clone, Debug)]
-/// Contains a set of field paths, and can answer an efficient field path contains queries.
+/// A set of field paths supporting efficient `contains` queries.
+///
+/// Paths are stored as inserted. Prefix-minimization—collapsing a path into an ancestor that
+/// already covers it—is deferred until the set is iterated via [`IntoIterator`], so insertion stays
+/// cheap.
 pub struct FieldPathSet {
-    /// While this is currently a set wrapper it can be replaced with a trie.
+    /// While this is currently a set wrapper it can be replaced with a trie, at which point the
+    /// deferred minimization in [`IntoIterator`] becomes cheap.
     // TODO(joe): this can be replaced with a `FieldPath` trie
     set: HashSet<FieldPath>,
 }
 
 impl FieldPathSet {
-    /// Checks if a set contains a field path
+    /// Checks if the set contains exactly this field path.
     pub fn contains(&self, path: &FieldPath) -> bool {
         self.set.contains(path)
     }
+
+    /// Iterates over the field paths in the set, as inserted (not prefix-minimized).
+    pub fn iter(&self) -> impl Iterator<Item = &FieldPath> {
+        self.set.iter()
+    }
+
+    /// Inserts a field path. Prefix-minimization is deferred until the set is iterated.
+    pub fn insert(&mut self, path: FieldPath) {
+        self.set.insert(path);
+    }
+}
+
+/// Reduces field paths to their minimal covering set: any path that has another path in the set as
+/// a prefix is redundant and dropped.
+fn minimal_covering_set(paths: impl IntoIterator<Item = FieldPath>) -> Vec<FieldPath> {
+    let mut covering: Vec<FieldPath> = Vec::new();
+    for path in paths {
+        if covering
+            .iter()
+            .any(|existing| path.parts().starts_with(existing.parts()))
+        {
+            continue;
+        }
+        covering.retain(|existing| !existing.parts().starts_with(path.parts()));
+        covering.push(path);
+    }
+    covering
+}
+
+impl Extend<FieldPath> for FieldPathSet {
+    fn extend<T: IntoIterator<Item = FieldPath>>(&mut self, iter: T) {
+        self.set.extend(iter);
+    }
 }
 
 impl FromIterator<FieldPath> for FieldPathSet {
@@ -260,6 +298,16 @@ impl FromIterator<FieldPath> for FieldPathSet {
     }
 }
 
+impl IntoIterator for FieldPathSet {
+    type Item = FieldPath;
+    type IntoIter = std::vec::IntoIter<FieldPath>;
+
+    /// Iterates the prefix-minimal covering set: redundant descendants are dropped.
+    fn into_iter(self) -> Self::IntoIter {
+        minimal_covering_set(self.set).into_iter()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -418,4 +466,17 @@ mod tests {
         assert!(!path1.overlap(&path3));
         assert!(!path3.overlap(&path1));
     }
+
+    #[test]
+    fn iteration_yields_minimal_covering_set() {
+        let mut paths = FieldPathSet::default();
+        paths.extend([field_path!(a.b), field_path!(x), field_path!(a)]);
+        paths.insert(field_path!(a.c));
+
+        // Iteration collapses `a.b`/`a.c` into the covering `a`.
+        assert_eq!(
+            paths.into_iter().collect::<HashSet<_>>(),
+            HashSet::from_iter([field_path!(a), field_path!(x)])
+        );
+    }
 }
diff --git a/vortex-array/src/expr/analysis/mod.rs b/vortex-array/src/expr/analysis/mod.rs
index a0b07eb96e6..f5208a31be8 100644
--- a/vortex-array/src/expr/analysis/mod.rs
+++ b/vortex-array/src/expr/analysis/mod.rs
@@ -6,6 +6,7 @@ mod fallible;
 pub mod immediate_access;
 mod labeling;
 mod null_sensitive;
+mod referenced_field_paths;
 
 pub use annotation::*;
 pub use fallible::label_is_fallible;
@@ -13,3 +14,4 @@ pub use immediate_access::*;
 pub use labeling::*;
 pub use null_sensitive::BooleanLabels;
 pub use null_sensitive::label_null_sensitive;
+pub use referenced_field_paths::referenced_field_paths;
diff --git a/vortex-array/src/expr/analysis/referenced_field_paths.rs b/vortex-array/src/expr/analysis/referenced_field_paths.rs
new file mode 100644
index 00000000000..5239e4a691c
--- /dev/null
+++ b/vortex-array/src/expr/analysis/referenced_field_paths.rs
@@ -0,0 +1,264 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexResult;
+use vortex_error::vortex_err;
+
+use crate::dtype::DType;
+use crate::dtype::Field;
+use crate::dtype::FieldPath;
+use crate::dtype::FieldPathSet;
+use crate::expr::Expression;
+use crate::expr::traversal::FoldDownContext;
+use crate::expr::traversal::FoldUp;
+use crate::expr::traversal::NodeExt;
+use crate::expr::traversal::NodeFolderContext;
+use crate::scalar_fn::fns::get_item::GetItem;
+use crate::scalar_fn::fns::root::Root;
+use crate::scalar_fn::fns::select::Select;
+
+/// Returns the rooted field paths referenced by an expression.
+///
+/// Iterating the returned set (via [`IntoIterator`]) yields the prefix-minimal covering set: when
+/// one referenced path is a prefix of another, only the prefix is kept. A standalone root
+/// expression is represented by [`FieldPath::root`], which conservatively selects all fields.
+/// Scalar functions other than `GetItem` and `Select` conservatively reference each complete child
+/// output.
+pub fn referenced_field_paths(expr: &Expression, scope: &DType) -> VortexResult<FieldPathSet> {
+    // Validate the whole expression so plain GetItem paths and Select paths behave consistently.
+    expr.return_dtype(scope)?;
+
+    let mut collector = ReferencedFieldPaths {
+        scope,
+        field_paths: FieldPathSet::default(),
+    };
+    expr.clone()
+        .fold_context(&vec![FieldPath::root()], &mut collector)?;
+    let field_paths = collector.field_paths;
+
+    // The top-level field of every referenced path must be one of the immediately accessed scope
+    // fields: this analysis only refines *which nested fields* are read, never which top-level
+    // fields. `FieldPath::root()` stands in for "all fields", so it expands to the whole scope.
+    #[cfg(debug_assertions)]
+    if let Some(scope_fields) = scope.as_struct_fields_opt() {
+        use vortex_utils::aliases::hash_set::HashSet;
+
+        use crate::dtype::FieldName;
+        use crate::expr::analysis::immediate_access::immediate_scope_access;
+
+        let referenced_heads: HashSet<FieldName> = if field_paths.iter().any(FieldPath::is_root) {
+            scope_fields.names().iter().cloned().collect()
+        } else {
+            field_paths
+                .iter()
+                .filter_map(|path| match path.parts().first() {
+                    Some(Field::Name(name)) => Some(name.clone()),
+                    _ => None,
+                })
+                .collect()
+        };
+        debug_assert_eq!(
+            referenced_heads,
+            immediate_scope_access(expr, scope_fields),
+            "referenced field path heads must match the immediately accessed scope fields"
+        );
+    }
+
+    Ok(field_paths)
+}
+
+/// Threads the set of currently-requested field paths down the expression tree, narrowing it at
+/// each `GetItem`/`Select`, and records the rooted paths reached at each `Root` leaf.
+///
+/// Paths are carried reversed so a `GetItem` can `push` its field instead of prepending it; they
+/// are reversed back to rooted order when recorded at a `Root`, and `Select` reads a path's head
+/// from its last element.
+///
+/// Narrowing is only sound through `GetItem` (a genuine field access) and `Select` (a genuine
+/// column projection). Any other function is opaque—we cannot assume it preserves a field's
+/// provenance—so its children conservatively re-request the whole scope, which is what keeps an
+/// expression like `f($).x` reading every field of `$` rather than just `x`.
+struct ReferencedFieldPaths<'a> {
+    scope: &'a DType,
+    field_paths: FieldPathSet,
+}
+
+impl NodeFolderContext for ReferencedFieldPaths<'_> {
+    type NodeTy = Expression;
+    type Result = ();
+    type Context = Vec<FieldPath>;
+
+    fn visit_down(
+        &mut self,
+        requested: &Self::Context,
+        node: &Expression,
+    ) -> VortexResult<FoldDownContext<Self::Context, ()>> {
+        if node.is::<Root>() {
+            self.field_paths.extend(
+                requested
+                    .iter()
+                    .map(|path| FieldPath::from_iter(path.parts().iter().rev().cloned())),
+            );
+            return Ok(FoldDownContext::Skip(()));
+        }
+
+        if let Some(field_name) = node.as_opt::<GetItem>() {
+            let appended = requested
+                .iter()
+                .map(|path| path.clone().push(Field::Name(field_name.clone())))
+                .collect();
+            return Ok(FoldDownContext::Continue(appended));
+        }
+
+        // Keep requested paths whose head is included, expanding a whole-scope request into one
+        // path per included field.
+        if let Some(selection) = node.as_opt::<Select>() {
+            let child_dtype = node.child(0).return_dtype(self.scope)?;
+            let child_fields = child_dtype
+                .as_struct_fields_opt()
+                .ok_or_else(|| vortex_err!("Select child is not a struct"))?;
+            let included_fields = selection.normalize_to_included_fields(child_fields.names())?;
+
+            let mut narrowed = Vec::with_capacity(requested.len());
+            for path in requested {
+                if path.is_root() {
+                    narrowed.extend(included_fields.iter().cloned().map(FieldPath::from_name));
+                } else if let Some(Field::Name(field_name)) = path.parts().last()
+                    && included_fields
+                        .iter()
+                        .any(|included| included == field_name)
+                {
+                    narrowed.push(path.clone());
+                }
+            }
+
+            // Nothing is requested below this `Select`, so prune the subtree rather than letting an
+            // opaque child re-request the whole scope.
+            if narrowed.is_empty() {
+                return Ok(FoldDownContext::Skip(()));
+            }
+            return Ok(FoldDownContext::Continue(narrowed));
+        }
+
+        // Any other function conservatively references each child's complete output.
+        Ok(FoldDownContext::Continue(vec![FieldPath::root()]))
+    }
+
+    fn visit_up(
+        &mut self,
+        _node: Expression,
+        _requested: &Self::Context,
+        _children: Vec<()>,
+    ) -> VortexResult<FoldUp<()>> {
+        Ok(FoldUp::Continue(()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_utils::aliases::hash_set::HashSet;
+
+    use super::*;
+    use crate::dtype::Nullability::NonNullable;
+    use crate::dtype::PType::I32;
+    use crate::dtype::StructFields;
+    use crate::expr::get_item;
+    use crate::expr::pack;
+    use crate::expr::root;
+    use crate::expr::select;
+    use crate::expr::select_exclude;
+
+    fn scope() -> DType {
+        DType::Struct(
+            StructFields::from_iter([(
+                "a",
+                DType::Struct(
+                    StructFields::from_iter([("x", I32), ("y", I32)]),
+                    NonNullable,
+                ),
+            )]),
+            NonNullable,
+        )
+    }
+
+    /// Collects the prefix-minimal field paths referenced by `expr` against [`scope`].
+    fn referenced(expr: &Expression) -> VortexResult<HashSet<FieldPath>> {
+        Ok(referenced_field_paths(expr, &scope())?
+            .into_iter()
+            .collect())
+    }
+
+    #[test]
+    fn nested_select_preserves_field_path() -> VortexResult<()> {
+        let expr = select(["x"], get_item("a", root()));
+
+        assert_eq!(
+            referenced(&expr)?,
+            HashSet::from_iter([FieldPath::from_name("a").push("x")])
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn get_item_after_select_only_references_requested_field() -> VortexResult<()> {
+        let expr = get_item("x", select(["x", "y"], get_item("a", root())));
+
+        assert_eq!(
+            referenced(&expr)?,
+            HashSet::from_iter([FieldPath::from_name("a").push("x")])
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn select_exclude_references_included_fields() -> VortexResult<()> {
+        let expr = select_exclude(["y"], get_item("a", root()));
+
+        assert_eq!(
+            referenced(&expr)?,
+            HashSet::from_iter([FieldPath::from_name("a").push("x")])
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn ancestor_path_subsumes_descendant() -> VortexResult<()> {
+        let expr = pack(
+            [
+                ("a", get_item("a", root())),
+                ("x", get_item("x", get_item("a", root()))),
+            ],
+            NonNullable,
+        );
+
+        assert_eq!(
+            referenced(&expr)?,
+            HashSet::from_iter([FieldPath::from_name("a")])
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn get_item_through_opaque_fn_references_all_fields() -> VortexResult<()> {
+        // `pack` is opaque to the path analysis: a `GetItem` of its output must not be pushed down
+        // as a scope field access, so the wrapped `root()` conservatively references all fields.
+        let expr = get_item("x", pack([("x", root())], NonNullable));
+
+        assert_eq!(referenced(&expr)?, HashSet::from_iter([FieldPath::root()]));
+        Ok(())
+    }
+
+    #[test]
+    fn root_references_all_fields() -> VortexResult<()> {
+        assert_eq!(
+            referenced(&root())?,
+            HashSet::from_iter([FieldPath::root()])
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn invalid_get_item_path_returns_error() {
+        assert!(referenced_field_paths(&get_item("missing", root()), &scope()).is_err());
+    }
+}
diff --git a/vortex-array/src/expr/exprs.rs b/vortex-array/src/expr/exprs.rs
index 3dd1f5ca265..73f4991d05c 100644
--- a/vortex-array/src/expr/exprs.rs
+++ b/vortex-array/src/expr/exprs.rs
@@ -4,6 +4,7 @@
 //! Factory functions for creating [`Expression`]s from scalar function vtables.
 
 use std::sync::Arc;
+use std::sync::LazyLock;
 
 use vortex_error::VortexExpect;
 use vortex_error::vortex_panic;
@@ -21,6 +22,7 @@ use crate::scalar_fn::ScalarFnVTableExt;
 use crate::scalar_fn::fns::between::Between;
 use crate::scalar_fn::fns::between::BetweenOptions;
 use crate::scalar_fn::fns::binary::Binary;
+use crate::scalar_fn::fns::byte_length::ByteLength;
 use crate::scalar_fn::fns::case_when::CaseWhen;
 use crate::scalar_fn::fns::case_when::CaseWhenOptions;
 use crate::scalar_fn::fns::cast::Cast;
@@ -51,20 +53,24 @@ use crate::scalar_fn::fns::variant_get::VariantGetOptions;
 use crate::scalar_fn::fns::variant_get::VariantPath;
 use crate::scalar_fn::fns::zip::Zip;
 
-// ---- Root ----
+static ROOT: LazyLock<Expression> = LazyLock::new(|| {
+    Root.try_new_expr(EmptyOptions, vec![])
+        .vortex_expect("Creating root() shouldn't fail")
+});
 
 /// Creates an expression that references the root scope.
 ///
 /// Returns the entire input array as passed to the expression evaluator.
 /// This is commonly used as the starting point for field access and other operations.
 pub fn root() -> Expression {
-    Root.try_new_expr(EmptyOptions, vec![])
-        .vortex_expect("Failed to create Root expression")
+    ROOT.clone()
 }
 
 /// Return whether the expression is a root expression.
 pub fn is_root(expr: &Expression) -> bool {
-    expr.is::<Root>()
+    // root doesn't have any children, and scalar_fns have distinct ids
+    // so we should almost always hit this eq check
+    (expr.scalar_fn().id() == ROOT.scalar_fn().id()) || expr.is::<Root>()
 }
 
 // ---- Literal ----
@@ -718,3 +724,16 @@ pub fn dynamic(
 pub fn list_contains(list: Expression, value: Expression) -> Expression {
     ListContains.new_expr(EmptyOptions, [list, value])
 }
+
+// ---- ByteLength ----
+
+/// Creates an expression that computes the byte length of each element.
+/// This is akin to ANSI SQL OCTET_LENGTH(), or DuckDB's strlen().
+///
+/// ```rust
+/// # use vortex_array::expr::{byte_length, root};
+/// let expr = byte_length(root());
+/// ```
+pub fn byte_length(input: Expression) -> Expression {
+    ByteLength.new_expr(EmptyOptions, [input])
+}
diff --git a/vortex-array/src/expression.rs b/vortex-array/src/expression.rs
index 780bfcf9db1..d6b8739abf6 100644
--- a/vortex-array/src/expression.rs
+++ b/vortex-array/src/expression.rs
@@ -35,7 +35,8 @@ impl ArrayRef {
 
         // And wrap the scalar function up in an array.
         let array =
-            ScalarFnArray::try_new(expr.scalar_fn().clone(), children, self.len())?.into_array();
+            ScalarFnArray::try_new_with_len(expr.scalar_fn().clone(), children, self.len())?
+                .into_array();
 
         // Optimize the resulting array's root.
         array.optimize()
diff --git a/vortex-array/src/extension/mod.rs b/vortex-array/src/extension/mod.rs
index 9f81e7fb310..a8cfda2d069 100644
--- a/vortex-array/src/extension/mod.rs
+++ b/vortex-array/src/extension/mod.rs
@@ -3,19 +3,8 @@
 
 //! Extension types.
 
-use std::fmt;
-
 pub mod datetime;
 pub mod uuid;
 
 #[cfg(test)]
 mod tests;
-
-/// An empty metadata struct for extension dtypes that do not require any metadata.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct EmptyMetadata;
-impl fmt::Display for EmptyMetadata {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "")
-    }
-}
diff --git a/vortex-array/src/extension/uuid/arrow.rs b/vortex-array/src/extension/uuid/arrow.rs
index 3d66ce99d58..cd4b97ea60a 100644
--- a/vortex-array/src/extension/uuid/arrow.rs
+++ b/vortex-array/src/extension/uuid/arrow.rs
@@ -142,7 +142,7 @@ impl ArrowImportVTable for Uuid {
             PType::U8,
             Validity::NonNullable,
         );
-        let validity = nulls(fsb.nulls(), dtype.is_nullable());
+        let validity = nulls(fsb.nulls(), dtype.is_nullable())?;
 
         let storage = FixedSizeListArray::new(
             u8_array.into_array(),
diff --git a/vortex-array/src/hash.rs b/vortex-array/src/hash.rs
index f45711e77d9..ab251af9deb 100644
--- a/vortex-array/src/hash.rs
+++ b/vortex-array/src/hash.rs
@@ -12,12 +12,12 @@ use vortex_mask::Mask;
 use crate::patches::Patches;
 use crate::validity::Validity;
 
-/// The precision level for structural equality and hashing of arrays.
+/// The equality mode for structural equality and hashing of arrays.
 ///
-/// This configuration option defines how precise the hash/equals results are given the set of
+/// This configuration option defines how precise the hash/equals results are for the set of
 /// data buffers backing the array.
 #[derive(Clone, Copy, Debug)]
-pub enum Precision {
+pub enum EqMode {
     /// Data buffers are compared by their pointer and length only. This is the fastest option, but
     /// may lead to false negatives if two arrays contain identical data but are backed by
     /// different buffers.
@@ -27,50 +27,50 @@ pub enum Precision {
     Value,
 }
 
-/// A hash trait for arrays that represents structural equality with a configurable level of
-/// precision. This trait is used primarily to implement common subtree elimination and other
+/// A hash trait for arrays that represents structural equality with a configurable equality mode.
+/// This trait is used primarily to implement common subtree elimination and other
 /// array-based caching mechanisms.
 ///
-/// The precision of the hash defines what level of structural equality is represented. See
-/// [`Precision`] for more details.
+/// The equality mode defines what level of structural equality is represented. See
+/// [`EqMode`] for more details.
 ///
-/// Note that where [`Precision::Ptr`] is used, the hash is only valid for the lifetime of the
+/// Note that where [`EqMode::Ptr`] is used, the hash is only valid for the lifetime of the
 /// object.
 pub trait ArrayHash {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision);
+    fn array_hash<H: Hasher>(&self, state: &mut H, eq_mode: EqMode);
 }
 
 /// A dynamic version of [`ArrayHash`].
 pub trait DynArrayDataHash: private::SealedHash {
-    fn dyn_array_hash(&self, state: &mut dyn Hasher, precision: Precision);
+    fn dyn_array_hash(&self, state: &mut dyn Hasher, eq_mode: EqMode);
 }
 
 impl<T: ArrayHash + ?Sized> DynArrayDataHash for T {
-    fn dyn_array_hash(&self, mut state: &mut dyn Hasher, precision: Precision) {
-        ArrayHash::array_hash(self, &mut state, precision);
+    fn dyn_array_hash(&self, mut state: &mut dyn Hasher, eq_mode: EqMode) {
+        ArrayHash::array_hash(self, &mut state, eq_mode);
     }
 }
 
-/// An equality trait for arrays that represents structural equality with a configurable level of
-/// precision. This trait is used primarily to implement common subtree elimination and other
+/// An equality trait for arrays that represents structural equality with a configurable equality
+/// mode. This trait is used primarily to implement common subtree elimination and other
 /// array-based caching mechanisms.
 ///
-/// The precision of the equality check defines what level of structural equality is represented. See
-/// [`Precision`] for more details.
+/// The equality mode defines what level of structural equality is represented. See
+/// [`EqMode`] for more details.
 pub trait ArrayEq {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool;
+    fn array_eq(&self, other: &Self, eq_mode: EqMode) -> bool;
 }
 
 /// A dynamic version of [`ArrayEq`].
 pub trait DynArrayDataEq: private::SealedEq {
-    fn dyn_array_eq(&self, other: &dyn Any, precision: Precision) -> bool;
+    fn dyn_array_eq(&self, other: &dyn Any, eq_mode: EqMode) -> bool;
 }
 
 impl<T: ArrayEq + 'static> DynArrayDataEq for T {
-    fn dyn_array_eq(&self, other: &dyn Any, precision: Precision) -> bool {
+    fn dyn_array_eq(&self, other: &dyn Any, eq_mode: EqMode) -> bool {
         other
             .downcast_ref::<Self>()
-            .is_some_and(|other| ArrayEq::array_eq(self, other, precision))
+            .is_some_and(|other| ArrayEq::array_eq(self, other, eq_mode))
     }
 }
 
@@ -85,36 +85,36 @@ mod private {
 }
 
 impl<T: Hash> ArrayHash for Buffer<T> {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
-        match precision {
-            Precision::Ptr => {
+    fn array_hash<H: Hasher>(&self, state: &mut H, eq_mode: EqMode) {
+        match eq_mode {
+            EqMode::Ptr => {
                 self.as_ptr().hash(state);
                 self.len().hash(state);
             }
-            Precision::Value => {
+            EqMode::Value => {
                 self.as_ref().hash(state);
             }
         }
     }
 }
 impl<T: PartialEq> ArrayEq for Buffer<T> {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
-        match precision {
-            Precision::Ptr => self.as_ptr() == other.as_ptr() && self.len() == other.len(),
-            Precision::Value => self.as_ref() == other.as_ref(),
+    fn array_eq(&self, other: &Self, eq_mode: EqMode) -> bool {
+        match eq_mode {
+            EqMode::Ptr => self.as_ptr() == other.as_ptr() && self.len() == other.len(),
+            EqMode::Value => self.as_ref() == other.as_ref(),
         }
     }
 }
 
 impl ArrayHash for BitBuffer {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
-        match precision {
-            Precision::Ptr => {
+    fn array_hash<H: Hasher>(&self, state: &mut H, eq_mode: EqMode) {
+        match eq_mode {
+            EqMode::Ptr => {
                 self.inner().as_ptr().hash(state);
                 self.offset().hash(state);
                 self.len().hash(state);
             }
-            Precision::Value => {
+            EqMode::Value => {
                 // NOTE(ngates): this is really rather expensive...
                 for chunk in self.chunks().iter_padded() {
                     chunk.hash(state);
@@ -124,24 +124,24 @@ impl ArrayHash for BitBuffer {
     }
 }
 impl ArrayEq for BitBuffer {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
-        match precision {
-            Precision::Ptr => {
+    fn array_eq(&self, other: &Self, eq_mode: EqMode) -> bool {
+        match eq_mode {
+            EqMode::Ptr => {
                 self.inner().as_ptr() == other.inner().as_ptr()
                     && self.offset() == other.offset()
                     && self.len() == other.len()
             }
-            Precision::Value => self.eq(other),
+            EqMode::Value => self.eq(other),
         }
     }
 }
 
 impl<T: ArrayHash> ArrayHash for Option<T> {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, eq_mode: EqMode) {
         match self {
             Some(value) => {
                 true.hash(state);
-                value.array_hash(state, precision);
+                value.array_hash(state, eq_mode);
             }
             None => {
                 false.hash(state);
@@ -151,9 +151,9 @@ impl<T: ArrayHash> ArrayHash for Option<T> {
 }
 
 impl<T: ArrayEq> ArrayEq for Option<T> {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, eq_mode: EqMode) -> bool {
         match (self, other) {
-            (Some(v1), Some(v2)) => v1.array_eq(v2, precision),
+            (Some(v1), Some(v2)) => v1.array_eq(v2, eq_mode),
             (None, None) => true,
             _ => false,
         }
@@ -161,7 +161,7 @@ impl<T: ArrayEq> ArrayEq for Option<T> {
 }
 
 impl ArrayHash for Mask {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, eq_mode: EqMode) {
         std::mem::discriminant(self).hash(state);
         match self {
             Mask::AllTrue(len) => {
@@ -171,18 +171,18 @@ impl ArrayHash for Mask {
                 len.hash(state);
             }
             Mask::Values(values) => {
-                values.bit_buffer().array_hash(state, precision);
+                values.bit_buffer().array_hash(state, eq_mode);
             }
         }
     }
 }
 impl ArrayEq for Mask {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, eq_mode: EqMode) -> bool {
         match (self, other) {
             (Mask::AllTrue(len1), Mask::AllTrue(len2)) => len1 == len2,
             (Mask::AllFalse(len1), Mask::AllFalse(len2)) => len1 == len2,
             (Mask::Values(buf1), Mask::Values(buf2)) => {
-                buf1.bit_buffer().array_eq(buf2.bit_buffer(), precision)
+                buf1.bit_buffer().array_eq(buf2.bit_buffer(), eq_mode)
             }
             _ => false,
         }
@@ -190,40 +190,40 @@ impl ArrayEq for Mask {
 }
 
 impl ArrayHash for Validity {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, eq_mode: EqMode) {
         std::mem::discriminant(self).hash(state);
         if let Validity::Array(array) = self {
-            array.array_hash(state, precision);
+            array.array_hash(state, eq_mode);
         }
     }
 }
 
 impl ArrayEq for Validity {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, eq_mode: EqMode) -> bool {
         match (self, other) {
             (Validity::AllValid, Validity::AllValid) => true,
             (Validity::AllInvalid, Validity::AllInvalid) => true,
             (Validity::NonNullable, Validity::NonNullable) => true,
-            (Validity::Array(arr1), Validity::Array(arr2)) => arr1.array_eq(arr2, precision),
+            (Validity::Array(arr1), Validity::Array(arr2)) => arr1.array_eq(arr2, eq_mode),
             _ => false,
         }
     }
 }
 
 impl ArrayHash for Patches {
-    fn array_hash<H: Hasher>(&self, state: &mut H, precision: Precision) {
+    fn array_hash<H: Hasher>(&self, state: &mut H, eq_mode: EqMode) {
         self.array_len().hash(state);
         self.offset().hash(state);
-        self.indices().array_hash(state, precision);
-        self.values().array_hash(state, precision);
+        self.indices().array_hash(state, eq_mode);
+        self.values().array_hash(state, eq_mode);
     }
 }
 
 impl ArrayEq for Patches {
-    fn array_eq(&self, other: &Self, precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, eq_mode: EqMode) -> bool {
         self.array_len() == other.array_len()
             && self.offset() == other.offset()
-            && self.indices().array_eq(other.indices(), precision)
-            && self.values().array_eq(other.values(), precision)
+            && self.indices().array_eq(other.indices(), eq_mode)
+            && self.values().array_eq(other.values(), eq_mode)
     }
 }
diff --git a/vortex-array/src/lib.rs b/vortex-array/src/lib.rs
index 0a9c5969ecc..1f3189eecbb 100644
--- a/vortex-array/src/lib.rs
+++ b/vortex-array/src/lib.rs
@@ -33,6 +33,7 @@ pub mod accessor;
 pub mod aggregate_fn;
 #[doc(hidden)]
 pub mod aliases;
+mod arc_swap_map;
 mod array;
 pub mod arrays;
 pub mod arrow;
diff --git a/vortex-array/src/matcher.rs b/vortex-array/src/matcher.rs
index 532931df083..c3f9e542f13 100644
--- a/vortex-array/src/matcher.rs
+++ b/vortex-array/src/matcher.rs
@@ -8,6 +8,7 @@ pub trait Matcher {
     type Match<'a>;
 
     /// Check if the given array matches this matcher type
+    #[inline]
     fn matches(array: &ArrayRef) -> bool {
         Self::try_match(array).is_some()
     }
diff --git a/vortex-array/src/metadata.rs b/vortex-array/src/metadata.rs
index 427f1040519..49baf97a19c 100644
--- a/vortex-array/src/metadata.rs
+++ b/vortex-array/src/metadata.rs
@@ -26,7 +26,7 @@ where
 }
 
 /// Empty array metadata
-#[derive(Debug)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct EmptyMetadata;
 
 impl SerializeMetadata for EmptyMetadata {
@@ -46,6 +46,12 @@ impl DeserializeMetadata for EmptyMetadata {
     }
 }
 
+impl std::fmt::Display for EmptyMetadata {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "")
+    }
+}
+
 /// A utility wrapper for raw metadata serialization. This delegates the serialiation step
 /// to the arrays' vtable.
 pub struct RawMetadata(pub Vec<u8>);
diff --git a/vortex-array/src/optimizer/kernels.rs b/vortex-array/src/optimizer/kernels.rs
index d38bc9402d1..93407a2c42d 100644
--- a/vortex-array/src/optimizer/kernels.rs
+++ b/vortex-array/src/optimizer/kernels.rs
@@ -26,21 +26,19 @@
 use std::any::Any;
 use std::borrow::Borrow;
 use std::hash::BuildHasher;
-use std::hash::Hash;
 use std::sync::Arc;
 use std::sync::LazyLock;
 
-use arc_swap::ArcSwap;
 use vortex_error::VortexResult;
 use vortex_session::Ref;
 use vortex_session::SessionExt;
 use vortex_session::SessionVar;
 use vortex_session::registry::Id;
 use vortex_utils::aliases::DefaultHashBuilder;
-use vortex_utils::aliases::hash_map::HashMap;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
+use crate::arc_swap_map::ArcSwapMap;
 use crate::array::VTable;
 use crate::arrays::Struct;
 use crate::arrays::struct_::compute::cast::struct_cast_execute_parent;
@@ -115,8 +113,8 @@ impl Borrow<u64> for ExecuteParentFnId {
 /// functions for an existing key appends them to that key's ordered list.
 #[derive(Debug)]
 pub struct ArrayKernels {
-    reduce_parent: ArcSwap<HashMap<ReduceParentFnId, Arc<[ReduceParentFn]>>>,
-    execute_parent: ArcSwap<HashMap<ExecuteParentFnId, Arc<[ExecuteParentFn]>>>,
+    reduce_parent: ArcSwapMap<ReduceParentFnId, Arc<[ReduceParentFn]>>,
+    execute_parent: ArcSwapMap<ExecuteParentFnId, Arc<[ExecuteParentFn]>>,
 }
 
 impl Default for ArrayKernels {
@@ -132,8 +130,8 @@ impl ArrayKernels {
     /// Create an empty [`ArrayKernels`] with no kernels registered.
     pub fn empty() -> Self {
         Self {
-            reduce_parent: ArcSwap::from_pointee(HashMap::default()),
-            execute_parent: ArcSwap::from_pointee(HashMap::default()),
+            reduce_parent: ArcSwapMap::default(),
+            execute_parent: ArcSwapMap::default(),
         }
     }
 
@@ -164,9 +162,8 @@ impl ArrayKernels {
     /// If functions have already been registered for the same pair, these functions are appended
     /// after them.
     pub fn register_reduce_parent(&self, parent: Id, child: Id, fns: &[ReduceParentFn]) {
-        self.reduce_parent.rcu(move |registry| {
-            update_fns(registry.as_ref().clone(), hash_fn_id(parent, child), fns)
-        });
+        self.reduce_parent
+            .extend(hash_fn_id(parent, child).into(), fns);
     }
 
     /// Look up the [`ReduceParentFn`]s registered for `(parent, child)`.
@@ -174,8 +171,7 @@ impl ArrayKernels {
     /// Returns an owned [`Arc`] so the session-variable borrow can be dropped before invoking the
     /// functions.
     pub fn find_reduce_parent(&self, parent: Id, child: Id) -> Option<Arc<[ReduceParentFn]>> {
-        let id = hash_fn_id(parent, child);
-        self.reduce_parent.load().get(&id).cloned()
+        self.reduce_parent.get(&hash_fn_id(parent, child))
     }
 
     /// Register [`ExecuteParentFn`]s for `(parent, child)`.
@@ -187,9 +183,8 @@ impl ArrayKernels {
     /// If functions have already been registered for the same pair, these functions are appended
     /// after them.
     pub fn register_execute_parent(&self, parent: Id, child: Id, fns: &[ExecuteParentFn]) {
-        self.execute_parent.rcu(move |registry| {
-            update_fns(registry.as_ref().clone(), hash_fn_id(parent, child), fns)
-        });
+        self.execute_parent
+            .extend(hash_fn_id(parent, child).into(), fns);
     }
 
     /// Look up the [`ExecuteParentFn`]s registered for `(parent, child)`.
@@ -197,8 +192,7 @@ impl ArrayKernels {
     /// Returns an owned [`Arc`] so the session-variable borrow can be dropped before invoking the
     /// functions.
     pub fn find_execute_parent(&self, parent: Id, child: Id) -> Option<Arc<[ExecuteParentFn]>> {
-        let id = hash_fn_id(parent, child);
-        self.execute_parent.load().get(&id).cloned()
+        self.execute_parent.get(&hash_fn_id(parent, child))
     }
 }
 
@@ -206,22 +200,6 @@ fn hash_fn_id(parent: Id, child: Id) -> u64 {
     FN_HASHER.hash_one((parent, child))
 }
 
-fn update_fns<F: Clone, K: Borrow<u64> + Eq + Hash + From<u64>>(
-    mut existing: HashMap<K, Arc<[F]>>,
-    id: u64,
-    fns: &[F],
-) -> HashMap<K, Arc<[F]>> {
-    if let Some(existing_fns) = existing.remove(&id) {
-        existing.insert(
-            id.into(),
-            existing_fns.as_ref().iter().chain(fns).cloned().collect(),
-        );
-    } else {
-        existing.insert(id.into(), fns.into());
-    }
-    existing
-}
-
 impl SessionVar for ArrayKernels {
     fn as_any(&self) -> &dyn Any {
         self
diff --git a/vortex-array/src/scalar/constructor.rs b/vortex-array/src/scalar/constructor.rs
index 2baf53c9528..16c87ca27a6 100644
--- a/vortex-array/src/scalar/constructor.rs
+++ b/vortex-array/src/scalar/constructor.rs
@@ -204,7 +204,7 @@ impl Scalar {
     }
 }
 
-/// A helper enum for creating a [`ListScalar`].
+/// A helper enum for creating a `ListScalar`.
 enum ListKind {
     /// Variable-length list.
     Variable,
diff --git a/vortex-array/src/scalar/scalar_value.rs b/vortex-array/src/scalar/scalar_value.rs
index 69122a9a16e..ebc2101fac6 100644
--- a/vortex-array/src/scalar/scalar_value.rs
+++ b/vortex-array/src/scalar/scalar_value.rs
@@ -16,7 +16,7 @@ use crate::scalar::DecimalValue;
 use crate::scalar::PValue;
 use crate::scalar::Scalar;
 
-/// The value stored in a [`Scalar`][crate::scalar::Scalar].
+/// The value stored in a [`Scalar`].
 ///
 /// This enum represents the possible non-null values that can be stored in a scalar. When the
 /// scalar is null, the value is represented as `None` in the `Option<ScalarValue>` field.
diff --git a/vortex-array/src/scalar/typed_view/extension/tests.rs b/vortex-array/src/scalar/typed_view/extension/tests.rs
index 909f8a4b11a..8bf52aa5369 100644
--- a/vortex-array/src/scalar/typed_view/extension/tests.rs
+++ b/vortex-array/src/scalar/typed_view/extension/tests.rs
@@ -4,13 +4,13 @@
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 
+use crate::EmptyMetadata;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::dtype::PType;
 use crate::dtype::extension::ExtDType;
 use crate::dtype::extension::ExtId;
 use crate::dtype::extension::ExtVTable;
-use crate::extension::EmptyMetadata;
 use crate::scalar::Scalar;
 use crate::scalar::ScalarValue;
 
diff --git a/vortex-array/src/scalar_fn/fns/between/mod.rs b/vortex-array/src/scalar_fn/fns/between/mod.rs
index 1c3dd0eef4f..0e0d9949195 100644
--- a/vortex-array/src/scalar_fn/fns/between/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/between/mod.rs
@@ -13,6 +13,7 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_proto::expr as pb;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 
 use crate::ArrayRef;
 use crate::Canonical;
@@ -176,7 +177,8 @@ impl ScalarFnVTable for Between {
     type Options = BetweenOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.between")
+        static ID: CachedId = CachedId::new("vortex.between");
+        *ID
     }
 
     fn serialize(&self, instance: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
diff --git a/vortex-array/src/scalar_fn/fns/binary/compare.rs b/vortex-array/src/scalar_fn/fns/binary/compare.rs
index a09a28164bd..5d4509fe406 100644
--- a/vortex-array/src/scalar_fn/fns/binary/compare.rs
+++ b/vortex-array/src/scalar_fn/fns/binary/compare.rs
@@ -26,7 +26,7 @@ use crate::arrays::scalar_fn::ScalarFnArrayExt;
 use crate::arrays::scalar_fn::ScalarFnArrayView;
 use crate::arrow::ArrowSessionExt;
 use crate::arrow::Datum;
-use crate::arrow::from_arrow_array_with_len;
+use crate::arrow::from_arrow_columnar;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::kernel::ExecuteParentKernel;
@@ -178,7 +178,7 @@ fn arrow_compare_arrays(
         }
     };
 
-    from_arrow_array_with_len(&arrow_array, left.len(), nullable)
+    from_arrow_columnar(&arrow_array, left.len(), nullable, ctx)
 }
 
 pub fn scalar_cmp(lhs: &Scalar, rhs: &Scalar, operator: CompareOperator) -> VortexResult<Scalar> {
diff --git a/vortex-array/src/scalar_fn/fns/binary/mod.rs b/vortex-array/src/scalar_fn/fns/binary/mod.rs
index 374d34d1ec9..1c860cb75b5 100644
--- a/vortex-array/src/scalar_fn/fns/binary/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/binary/mod.rs
@@ -12,6 +12,7 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_proto::expr as pb;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
@@ -52,7 +53,8 @@ impl ScalarFnVTable for Binary {
     type Options = Operator;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.binary")
+        static ID: CachedId = CachedId::new("vortex.binary");
+        *ID
     }
 
     fn serialize(&self, instance: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
diff --git a/vortex-array/src/scalar_fn/fns/binary/numeric.rs b/vortex-array/src/scalar_fn/fns/binary/numeric.rs
index 9429a7310d1..2ef58fb5209 100644
--- a/vortex-array/src/scalar_fn/fns/binary/numeric.rs
+++ b/vortex-array/src/scalar_fn/fns/binary/numeric.rs
@@ -8,7 +8,7 @@ use crate::IntoArray;
 use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
 use crate::arrow::Datum;
-use crate::arrow::from_arrow_array_with_len;
+use crate::arrow::from_arrow_columnar;
 use crate::executor::ExecutionCtx;
 use crate::scalar::NumericOperator;
 
@@ -48,7 +48,7 @@ pub(crate) fn arrow_numeric(
         NumericOperator::Div => arrow_arith::numeric::div(&left, &right)?,
     };
 
-    from_arrow_array_with_len(array.as_ref(), len, nullable)
+    from_arrow_columnar(array.as_ref(), len, nullable, ctx)
 }
 
 fn constant_numeric(
diff --git a/vortex-array/src/scalar_fn/fns/byte_length.rs b/vortex-array/src/scalar_fn/fns/byte_length.rs
new file mode 100644
index 00000000000..13a4f3158b5
--- /dev/null
+++ b/vortex-array/src/scalar_fn/fns/byte_length.rs
@@ -0,0 +1,248 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use num_traits::AsPrimitive;
+use vortex_buffer::Buffer;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_ensure;
+use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
+
+use crate::ArrayRef;
+use crate::ExecutionCtx;
+use crate::IntoArray;
+use crate::array::ArrayView;
+use crate::array::VTable;
+use crate::arrays::ConstantArray;
+use crate::arrays::PrimitiveArray;
+use crate::arrays::VarBinViewArray;
+use crate::arrays::scalar_fn::ExactScalarFn;
+use crate::arrays::scalar_fn::ScalarFnArrayView;
+use crate::arrays::varbinview::VarBinViewArrayExt;
+use crate::dtype::DType;
+use crate::dtype::Nullability;
+use crate::dtype::PType;
+use crate::kernel::ExecuteParentKernel;
+use crate::scalar::Scalar;
+use crate::scalar_fn::Arity;
+use crate::scalar_fn::ChildName;
+use crate::scalar_fn::EmptyOptions;
+use crate::scalar_fn::ExecutionArgs;
+use crate::scalar_fn::ScalarFnId;
+use crate::scalar_fn::ScalarFnVTable;
+
+pub trait ByteLengthKernel: VTable {
+    fn byte_length(
+        array: ArrayView<'_, Self>,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>>;
+}
+
+#[derive(Default, Debug)]
+pub struct ByteLengthExecuteAdaptor<V>(pub V);
+
+impl<V: ByteLengthKernel> ExecuteParentKernel<V> for ByteLengthExecuteAdaptor<V> {
+    type Parent = ExactScalarFn<ByteLength>;
+
+    fn execute_parent(
+        &self,
+        array: ArrayView<'_, V>,
+        _parent: ScalarFnArrayView<'_, ByteLength>,
+        child_idx: usize,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<ArrayRef>> {
+        vortex_ensure!(child_idx == 0);
+        V::byte_length(array, ctx)
+    }
+}
+
+/// Byte length of each element in a Utf8 or Binary array.
+#[derive(Clone)]
+pub struct ByteLength;
+
+impl ScalarFnVTable for ByteLength {
+    type Options = EmptyOptions;
+
+    fn id(&self) -> ScalarFnId {
+        static ID: CachedId = CachedId::new("vortex.byte_length");
+        *ID
+    }
+
+    fn serialize(&self, _instance: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(vec![]))
+    }
+
+    fn deserialize(
+        &self,
+        _metadata: &[u8],
+        _session: &VortexSession,
+    ) -> VortexResult<Self::Options> {
+        Ok(EmptyOptions)
+    }
+
+    fn arity(&self, _options: &Self::Options) -> Arity {
+        Arity::Exact(1)
+    }
+
+    fn child_name(&self, _instance: &Self::Options, child_idx: usize) -> ChildName {
+        match child_idx {
+            0 => ChildName::from("input"),
+            _ => unreachable!("Invalid child index {child_idx} for byte_length()"),
+        }
+    }
+
+    fn return_dtype(&self, _options: &Self::Options, arg_dtypes: &[DType]) -> VortexResult<DType> {
+        match &arg_dtypes[0] {
+            DType::Utf8(nullable) | DType::Binary(nullable) => {
+                Ok(DType::Primitive(PType::U64, *nullable))
+            }
+            other => vortex_bail!("byte_length() requires Utf8 or Binary, got {other}"),
+        }
+    }
+
+    fn execute(
+        &self,
+        _options: &Self::Options,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let input = args.get(0)?;
+        let nullability = input.dtype().nullability();
+
+        if let Some(scalar) = input.as_constant() {
+            let len_scalar = scalar_byte_length(&scalar, nullability)?;
+            return Ok(ConstantArray::new(len_scalar, args.row_count()).into_array());
+        }
+
+        match input.dtype() {
+            DType::Utf8(_) | DType::Binary(_) => byte_length(&input, nullability, ctx),
+            other => vortex_bail!("byte_length() requires Utf8 or Binary, got {other}"),
+        }
+    }
+
+    fn is_null_sensitive(&self, _options: &Self::Options) -> bool {
+        false
+    }
+
+    fn is_fallible(&self, _options: &Self::Options) -> bool {
+        false
+    }
+}
+
+fn scalar_byte_length(scalar: &Scalar, nullability: Nullability) -> VortexResult<Scalar> {
+    if scalar.is_null() {
+        let dtype = DType::Primitive(PType::U64, Nullability::Nullable);
+        return Ok(Scalar::null(dtype));
+    }
+    let len = match scalar.dtype() {
+        DType::Utf8(_) => scalar
+            .as_utf8()
+            .value()
+            .vortex_expect("null utf-8 scalar")
+            .len(),
+        DType::Binary(_) => scalar
+            .as_binary()
+            .value()
+            .vortex_expect("null binary scalar")
+            .len(),
+        other => vortex_bail!("byte_length() requires Utf8 or Binary, got {other}"),
+    };
+    let len: u64 = len.as_();
+    Ok(Scalar::primitive(len, nullability))
+}
+
+pub(crate) fn byte_length(
+    array: &ArrayRef,
+    nullability: Nullability,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ArrayRef> {
+    let array = array.clone().execute::<VarBinViewArray>(ctx)?;
+    let validity = array.varbinview_validity();
+    let lengths: Buffer<u64> = array.views().iter().map(|v| v.len() as u64).collect();
+    Ok(PrimitiveArray::new(lengths, validity.union_nullability(nullability)).into_array())
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+    use vortex_error::VortexResult;
+
+    use crate::ArrayRef;
+    use crate::IntoArray;
+    use crate::LEGACY_SESSION;
+    use crate::VortexSessionExecute;
+    use crate::arrays::ConstantArray;
+    use crate::arrays::PrimitiveArray;
+    use crate::arrays::VarBinArray;
+    use crate::arrays::VarBinViewArray;
+    use crate::assert_arrays_eq;
+    use crate::dtype::DType;
+    use crate::dtype::Nullability;
+    use crate::expr::byte_length;
+    use crate::expr::root;
+    use crate::scalar::Scalar;
+
+    #[rstest]
+    #[case(VarBinArray::from_strs(vec!["hello", "world", ""]).into_array(), vec![5u64, 5, 0])]
+    #[case(VarBinArray::from_bytes(vec![b"ab".as_ref(), b"cde"]).into_array(), vec![2u64, 3])]
+    #[case(VarBinArray::from_strs(vec!["Пуховички"]).into_array(), vec![18u64])]
+    #[case(VarBinArray::from_bytes(vec!["Пуховички".as_ref()]).into_array(), vec![18u64])]
+    fn test_bytes_byte_length(
+        #[case] array: ArrayRef,
+        #[case] expected_lens: Vec<u64>,
+    ) -> VortexResult<()> {
+        let result = array.apply(&byte_length(root()))?;
+        let expected = PrimitiveArray::from_iter(expected_lens);
+        assert_arrays_eq!(result, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn test_varbinview_byte_length() -> VortexResult<()> {
+        let array = VarBinViewArray::from_iter_str(["short", "a longer string here"]).into_array();
+        let result = array.apply(&byte_length(root()))?;
+        let expected = PrimitiveArray::from_iter(vec![5u64, 20]);
+        assert_arrays_eq!(result, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn test_nullable_string_byte_length() -> VortexResult<()> {
+        let array = VarBinArray::from_nullable_strs(vec![Some("hello"), None, Some("Пуховички")])
+            .into_array();
+        let result = array.apply(&byte_length(root()))?;
+
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert!(result.is_valid(0, &mut ctx)?);
+        assert!(!result.is_valid(1, &mut ctx)?);
+        assert!(result.is_valid(2, &mut ctx)?);
+        assert_eq!(
+            result.execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())?,
+            Scalar::primitive(5u64, Nullability::Nullable),
+        );
+        assert_eq!(
+            result.execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())?,
+            Scalar::primitive(18u64, Nullability::Nullable),
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_null_scalar_byte_length() -> VortexResult<()> {
+        let null_scalar = Scalar::null(DType::Utf8(Nullability::Nullable));
+        let array = ConstantArray::new(null_scalar, 2).into_array();
+        let result = array.apply(&byte_length(root()))?;
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert!(!result.is_valid(0, &mut ctx)?);
+        assert!(!result.is_valid(1, &mut ctx)?);
+        Ok(())
+    }
+
+    #[test]
+    fn test_display() {
+        let expr = byte_length(root());
+        assert_eq!(expr.to_string(), "vortex.byte_length($)");
+    }
+}
diff --git a/vortex-array/src/scalar_fn/fns/case_when.rs b/vortex-array/src/scalar_fn/fns/case_when.rs
index e018afee35a..c178e536b38 100644
--- a/vortex-array/src/scalar_fn/fns/case_when.rs
+++ b/vortex-array/src/scalar_fn/fns/case_when.rs
@@ -22,6 +22,7 @@ use vortex_mask::AllOr;
 use vortex_mask::Mask;
 use vortex_proto::expr as pb;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
@@ -40,6 +41,10 @@ use crate::scalar_fn::ChildName;
 use crate::scalar_fn::ExecutionArgs;
 use crate::scalar_fn::ScalarFnId;
 use crate::scalar_fn::ScalarFnVTable;
+use crate::scalar_fn::SimplifyCtx;
+use crate::scalar_fn::fns::is_not_null::IsNotNull;
+use crate::scalar_fn::fns::is_null::IsNull;
+use crate::scalar_fn::fns::literal::Literal;
 use crate::scalar_fn::fns::zip::zip_impl;
 
 /// Options for the n-ary CaseWhen expression.
@@ -79,7 +84,8 @@ impl ScalarFnVTable for CaseWhen {
     type Options = CaseWhenOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.case_when")
+        static ID: CachedId = CachedId::new("vortex.case_when");
+        *ID
     }
 
     fn serialize(&self, _options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
@@ -249,6 +255,51 @@ impl ScalarFnVTable for CaseWhen {
         merge_case_branches(branches, else_value, ctx)
     }
 
+    fn simplify(
+        &self,
+        options: &Self::Options,
+        expr: &Expression,
+        _ctx: &dyn SimplifyCtx,
+    ) -> VortexResult<Option<Expression>> {
+        // Rewrite the COALESCE-shaped CASE WHEN into `fill_null`, which references `x`
+        // once and lowers to a single fill kernel instead of a `zip`/merge that resolves
+        // `x` twice (once for the `is_null` predicate, once for the value branch).
+        //
+        //   CASE WHEN is_null(x)     THEN c ELSE x END  ==>  fill_null(x, c)
+        //   CASE WHEN is_not_null(x) THEN x ELSE c END  ==>  fill_null(x, c)
+        //
+        // The fill `c` must be a `Literal`: `fill_null`'s kernel reads the fill value via
+        // `as_constant()`, so a non-constant fill would produce an unexecutable expression.
+        if options.num_when_then_pairs != 1 || !options.has_else {
+            return Ok(None);
+        }
+
+        let when = expr.child(0);
+        let then = expr.child(1);
+        let els = expr.child(2);
+
+        // `is_null(x) ? c : x` — predicate operand and ELSE are the same `x`, fill is THEN.
+        let (x, fill) = if when.is::<IsNull>() && when.child(0) == els {
+            (els, then)
+        // `is_not_null(x) ? x : c` — predicate operand and THEN are the same `x`, fill is ELSE.
+        } else if when.is::<IsNotNull>() && when.child(0) == then {
+            (then, els)
+        } else {
+            return Ok(None);
+        };
+
+        let Some(scalar) = fill.as_opt::<Literal>() else {
+            return Ok(None);
+        };
+
+        if scalar.is_null() {
+            // Filling the nulls of `x` with NULL is a no-op
+            return Ok(Some(x.clone()));
+        }
+
+        Ok(Some(crate::expr::fill_null(x.clone(), fill.clone())))
+    }
+
     fn is_null_sensitive(&self, _options: &Self::Options) -> bool {
         true
     }
@@ -408,12 +459,15 @@ mod tests {
     use crate::dtype::DType;
     use crate::dtype::Nullability;
     use crate::dtype::PType;
+    use crate::dtype::StructFields;
     use crate::expr::case_when;
     use crate::expr::case_when_no_else;
     use crate::expr::col;
     use crate::expr::eq;
     use crate::expr::get_item;
     use crate::expr::gt;
+    use crate::expr::is_not_null;
+    use crate::expr::is_null;
     use crate::expr::lit;
     use crate::expr::nested_case_when;
     use crate::expr::root;
@@ -1191,6 +1245,170 @@ mod tests {
         assert_arrays_eq!(result, buffer![10i32, 20, 0].into_array());
     }
 
+    // ==================== Simplify: COALESCE -> fill_null ====================
+
+    /// Builds a non-nullable struct scope whose named fields are all `Nullable(I64)`.
+    fn nullable_i64_scope(fields: &[&str]) -> DType {
+        DType::Struct(
+            StructFields::new(
+                fields.to_vec().into(),
+                vec![DType::Primitive(PType::I64, Nullability::Nullable); fields.len()],
+            ),
+            Nullability::NonNullable,
+        )
+    }
+
+    #[test]
+    fn test_simplify_coalesce_is_null_rewrites_to_fill_null() -> VortexResult<()> {
+        // CASE WHEN is_null(x) THEN 0 ELSE x END  ==>  fill_null(x, 0)
+        let expr = case_when(is_null(col("x")), lit(0i64), col("x"));
+        let optimized = expr.optimize_recursive(&nullable_i64_scope(&["x"]))?;
+        assert!(
+            optimized.to_string().starts_with("vortex.fill_null"),
+            "expected fill_null, got {optimized}"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_simplify_coalesce_is_not_null_rewrites_to_fill_null() -> VortexResult<()> {
+        // CASE WHEN is_not_null(x) THEN x ELSE 0 END  ==>  fill_null(x, 0)
+        let expr = case_when(is_not_null(col("x")), col("x"), lit(0i64));
+        let optimized = expr.optimize_recursive(&nullable_i64_scope(&["x"]))?;
+        assert!(
+            optimized.to_string().starts_with("vortex.fill_null"),
+            "expected fill_null, got {optimized}"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_simplify_does_not_fire_when_operands_differ() -> VortexResult<()> {
+        // The is_null operand (x) and the ELSE (y) are different columns: not a COALESCE.
+        let expr = case_when(is_null(col("x")), lit(0i64), col("y"));
+        let optimized = expr.optimize_recursive(&nullable_i64_scope(&["x", "y"]))?;
+        let s = optimized.to_string();
+        assert!(s.contains("CASE"), "expected CASE WHEN to remain, got {s}");
+        assert!(!s.contains("fill_null"), "must not rewrite, got {s}");
+        Ok(())
+    }
+
+    #[test]
+    fn test_simplify_does_not_fire_for_non_constant_fill() -> VortexResult<()> {
+        // COALESCE(x, c) with a *column* fill: fill_null cannot consume a non-constant
+        // fill value, so the rewrite must not fire.
+        let expr = case_when(is_null(col("x")), col("c"), col("x"));
+        let optimized = expr.optimize_recursive(&nullable_i64_scope(&["x", "c"]))?;
+        let s = optimized.to_string();
+        assert!(s.contains("CASE"), "expected CASE WHEN to remain, got {s}");
+        assert!(!s.contains("fill_null"), "must not rewrite, got {s}");
+        Ok(())
+    }
+
+    #[test]
+    fn test_simplify_null_fill_collapses_to_input() -> VortexResult<()> {
+        // Filling the nulls of x with NULL is a no-op, so both forms collapse to just `x`.
+        //   CASE WHEN is_null(x)     THEN null ELSE x    END  ==>  x
+        //   CASE WHEN is_not_null(x) THEN x    ELSE null END  ==>  x
+        let null_fill = || {
+            lit(Scalar::null(DType::Primitive(
+                PType::I64,
+                Nullability::Nullable,
+            )))
+        };
+
+        for expr in [
+            case_when(is_null(col("x")), null_fill(), col("x")),
+            case_when(is_not_null(col("x")), col("x"), null_fill()),
+        ] {
+            let optimized = expr.optimize_recursive(&nullable_i64_scope(&["x"]))?;
+            assert_eq!(
+                optimized.to_string(),
+                "$.x",
+                "expected collapse to input column, got {optimized}"
+            );
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_simplify_null_fill_semantic_equivalence() -> VortexResult<()> {
+        // The collapse-to-input rewrite must preserve values (and `x`'s nullability).
+        let array = PrimitiveArray::from_option_iter([Some(1i64), None, Some(3)]).into_array();
+        let scope = DType::Primitive(PType::I64, Nullability::Nullable);
+        let null_fill = lit(Scalar::null(DType::Primitive(
+            PType::I64,
+            Nullability::Nullable,
+        )));
+
+        let original = case_when(is_null(root()), null_fill, root());
+        let optimized = original.optimize_recursive(&scope)?;
+        assert_eq!(
+            optimized.to_string(),
+            "$",
+            "expected collapse to root, got {optimized}"
+        );
+
+        let expected = PrimitiveArray::from_option_iter([Some(1i64), None, Some(3)]).into_array();
+        assert_arrays_eq!(evaluate_expr(&original, &array), expected);
+        assert_arrays_eq!(evaluate_expr(&optimized, &array), expected);
+        Ok(())
+    }
+
+    #[test]
+    fn test_simplify_does_not_fire_without_else() -> VortexResult<()> {
+        let expr = case_when_no_else(is_null(col("x")), lit(0i64));
+        let optimized = expr.optimize_recursive(&nullable_i64_scope(&["x"]))?;
+        assert!(
+            !optimized.to_string().contains("fill_null"),
+            "must not rewrite a no-ELSE case_when, got {optimized}"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_simplify_does_not_fire_for_multi_pair() -> VortexResult<()> {
+        let expr = nested_case_when(
+            vec![
+                (is_null(col("x")), lit(0i64)),
+                (gt(col("x"), lit(5i64)), lit(1i64)),
+            ],
+            Some(col("x")),
+        );
+        let optimized = expr.optimize_recursive(&nullable_i64_scope(&["x"]))?;
+        assert!(
+            !optimized.to_string().contains("fill_null"),
+            "must not rewrite a multi-pair case_when, got {optimized}"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_simplify_semantic_equivalence() -> VortexResult<()> {
+        // The optimized expression must produce the same values as the original CASE WHEN.
+        let array = PrimitiveArray::from_option_iter([Some(1i64), None, Some(3)]).into_array();
+        let scope = DType::Primitive(PType::I64, Nullability::Nullable);
+
+        let original = case_when(is_null(root()), lit(0i64), root());
+        let optimized = original.optimize_recursive(&scope)?;
+        assert!(
+            optimized.to_string().starts_with("vortex.fill_null"),
+            "expected fill_null, got {optimized}"
+        );
+
+        // Original keeps CASE WHEN's nullable result dtype; the rewrite tightens it to
+        // NonNullable because a non-null fill cannot leave any nulls behind. Values match.
+        assert_arrays_eq!(
+            evaluate_expr(&original, &array),
+            PrimitiveArray::from_option_iter([Some(1i64), Some(0), Some(3)]).into_array()
+        );
+        assert_arrays_eq!(
+            evaluate_expr(&optimized, &array),
+            buffer![1i64, 0, 3].into_array()
+        );
+        Ok(())
+    }
+
     #[test]
     fn test_merge_case_branches_alternating_mask() -> VortexResult<()> {
         // Exercises the scalar path: alternating rows produce one slice per row (no runs),
diff --git a/vortex-array/src/scalar_fn/fns/cast/mod.rs b/vortex-array/src/scalar_fn/fns/cast/mod.rs
index a007788acb2..abc59af2c9a 100644
--- a/vortex-array/src/scalar_fn/fns/cast/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/cast/mod.rs
@@ -12,6 +12,7 @@ use vortex_error::vortex_bail;
 use vortex_error::vortex_err;
 use vortex_proto::expr as pb;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 
 use crate::AnyColumnar;
 use crate::ArrayRef;
@@ -53,7 +54,8 @@ impl ScalarFnVTable for Cast {
     type Options = DType;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.cast")
+        static ID: CachedId = CachedId::new("vortex.cast");
+        *ID
     }
 
     fn serialize(&self, dtype: &DType) -> VortexResult<Option<Vec<u8>>> {
diff --git a/vortex-array/src/scalar_fn/fns/dynamic.rs b/vortex-array/src/scalar_fn/fns/dynamic.rs
index e25117b36bc..7efebf79220 100644
--- a/vortex-array/src/scalar_fn/fns/dynamic.rs
+++ b/vortex-array/src/scalar_fn/fns/dynamic.rs
@@ -12,6 +12,7 @@ use parking_lot::Mutex;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
+use vortex_session::registry::CachedId;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
@@ -46,7 +47,8 @@ impl ScalarFnVTable for DynamicComparison {
     type Options = DynamicComparisonExpr;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::from("vortex.dynamic")
+        static ID: CachedId = CachedId::new("vortex.dynamic");
+        *ID
     }
 
     fn arity(&self, _options: &Self::Options) -> Arity {
diff --git a/vortex-array/src/scalar_fn/fns/fill_null/mod.rs b/vortex-array/src/scalar_fn/fns/fill_null/mod.rs
index bde1694fdb5..b2d07b41255 100644
--- a/vortex-array/src/scalar_fn/fns/fill_null/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/fill_null/mod.rs
@@ -9,6 +9,7 @@ use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 
 use crate::AnyColumnar;
 use crate::ArrayRef;
@@ -37,7 +38,8 @@ impl ScalarFnVTable for FillNull {
     type Options = EmptyOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.fill_null")
+        static ID: CachedId = CachedId::new("vortex.fill_null");
+        *ID
     }
 
     fn serialize(&self, _options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
diff --git a/vortex-array/src/scalar_fn/fns/get_item.rs b/vortex-array/src/scalar_fn/fns/get_item.rs
index 3f41e9b69c8..de7e45ca9b0 100644
--- a/vortex-array/src/scalar_fn/fns/get_item.rs
+++ b/vortex-array/src/scalar_fn/fns/get_item.rs
@@ -8,6 +8,7 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_err;
 use vortex_proto::expr as pb;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
@@ -44,7 +45,8 @@ impl ScalarFnVTable for GetItem {
     type Options = FieldName;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.get_item")
+        static ID: CachedId = CachedId::new("vortex.get_item");
+        *ID
     }
 
     fn serialize(&self, instance: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
diff --git a/vortex-array/src/scalar_fn/fns/is_not_null.rs b/vortex-array/src/scalar_fn/fns/is_not_null.rs
index 26e474cc447..589333304e2 100644
--- a/vortex-array/src/scalar_fn/fns/is_not_null.rs
+++ b/vortex-array/src/scalar_fn/fns/is_not_null.rs
@@ -6,6 +6,7 @@ use std::fmt::Formatter;
 use vortex_array::scalar_fn::internal::row_count::RowCount;
 use vortex_error::VortexResult;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
@@ -34,7 +35,8 @@ impl ScalarFnVTable for IsNotNull {
     type Options = EmptyOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.is_not_null")
+        static ID: CachedId = CachedId::new("vortex.is_not_null");
+        *ID
     }
 
     fn serialize(&self, _instance: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
diff --git a/vortex-array/src/scalar_fn/fns/is_null.rs b/vortex-array/src/scalar_fn/fns/is_null.rs
index ee0aab280ee..7315fbe8c07 100644
--- a/vortex-array/src/scalar_fn/fns/is_null.rs
+++ b/vortex-array/src/scalar_fn/fns/is_null.rs
@@ -3,6 +3,7 @@
 
 use vortex_error::VortexResult;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
@@ -32,7 +33,8 @@ impl ScalarFnVTable for IsNull {
     type Options = EmptyOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::from("vortex.is_null")
+        static ID: CachedId = CachedId::new("vortex.is_null");
+        *ID
     }
 
     fn serialize(&self, _instance: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
diff --git a/vortex-array/src/scalar_fn/fns/like/mod.rs b/vortex-array/src/scalar_fn/fns/like/mod.rs
index a99854d7e89..b7f357020f1 100644
--- a/vortex-array/src/scalar_fn/fns/like/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/like/mod.rs
@@ -13,11 +13,12 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_proto::expr as pb;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::arrow::Datum;
-use crate::arrow::from_arrow_array_with_len;
+use crate::arrow::from_arrow_columnar;
 use crate::dtype::DType;
 use crate::expr::Expression;
 use crate::expr::StatsCatalog;
@@ -63,7 +64,8 @@ impl ScalarFnVTable for Like {
     type Options = LikeOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.like")
+        static ID: CachedId = CachedId::new("vortex.like");
+        *ID
     }
 
     fn serialize(&self, instance: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
@@ -235,7 +237,7 @@ pub(crate) fn arrow_like(
         (true, true) => arrow_string::like::nilike(&lhs, &rhs)?,
     };
 
-    from_arrow_array_with_len(&result, len, nullable)
+    from_arrow_columnar(&result, len, nullable, ctx)
 }
 
 /// Variants of the LIKE filter that we know how to turn into a stats pruning predicate.
diff --git a/vortex-array/src/scalar_fn/fns/list_contains/mod.rs b/vortex-array/src/scalar_fn/fns/list_contains/mod.rs
index e964af75a32..978a1da1caf 100644
--- a/vortex-array/src/scalar_fn/fns/list_contains/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/list_contains/mod.rs
@@ -14,6 +14,7 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_err;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 use vortex_utils::iter::ReduceBalancedIterExt;
 
 use crate::ArrayRef;
@@ -61,7 +62,8 @@ impl ScalarFnVTable for ListContains {
     type Options = EmptyOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.list.contains")
+        static ID: CachedId = CachedId::new("vortex.list.contains");
+        *ID
     }
 
     fn serialize(&self, _instance: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
@@ -356,7 +358,7 @@ where
 {
     let offsets_slice = offsets.as_slice::<O>();
     let sizes_slice = sizes.as_slice::<S>();
-    let bits = matches.to_bit_buffer();
+    let bits = matches.bit_buffer_view();
 
     (0..list_array_len)
         .map(|i| {
@@ -365,7 +367,7 @@ where
 
             // BitIndexIterator yields indices of true bits only. If `.next()` returns
             // `Some(_)`, at least one element in this list's range matches.
-            let mut set_bits = BitIndexIterator::new(bits.inner().as_ref(), offset, size);
+            let mut set_bits = BitIndexIterator::new(bits.inner(), offset, size);
             set_bits.next().is_some()
         })
         .collect::<BitBuffer>()
diff --git a/vortex-array/src/scalar_fn/fns/literal.rs b/vortex-array/src/scalar_fn/fns/literal.rs
index 97d8089a5bf..16b112e5a78 100644
--- a/vortex-array/src/scalar_fn/fns/literal.rs
+++ b/vortex-array/src/scalar_fn/fns/literal.rs
@@ -8,6 +8,7 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_err;
 use vortex_proto::expr as pb;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
@@ -38,7 +39,8 @@ impl ScalarFnVTable for Literal {
     type Options = Scalar;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::from("vortex.literal")
+        static ID: CachedId = CachedId::new("vortex.literal");
+        *ID
     }
 
     fn serialize(&self, instance: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
diff --git a/vortex-array/src/scalar_fn/fns/mask/mod.rs b/vortex-array/src/scalar_fn/fns/mask/mod.rs
index 259f4b34e18..4dd55948ec8 100644
--- a/vortex-array/src/scalar_fn/fns/mask/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/mask/mod.rs
@@ -8,6 +8,7 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 
 use crate::ArrayRef;
 use crate::Canonical;
@@ -44,7 +45,8 @@ impl ScalarFnVTable for Mask {
     type Options = EmptyOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.mask")
+        static ID: CachedId = CachedId::new("vortex.mask");
+        *ID
     }
 
     fn serialize(&self, _options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
diff --git a/vortex-array/src/scalar_fn/fns/merge.rs b/vortex-array/src/scalar_fn/fns/merge.rs
index 608ba69a255..390d3a2213e 100644
--- a/vortex-array/src/scalar_fn/fns/merge.rs
+++ b/vortex-array/src/scalar_fn/fns/merge.rs
@@ -11,6 +11,7 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 use vortex_utils::aliases::hash_set::HashSet;
 
 use crate::ArrayRef;
@@ -51,7 +52,8 @@ impl ScalarFnVTable for Merge {
     type Options = DuplicateHandling;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::from("vortex.merge")
+        static ID: CachedId = CachedId::new("vortex.merge");
+        *ID
     }
 
     fn serialize(&self, instance: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
diff --git a/vortex-array/src/scalar_fn/fns/mod.rs b/vortex-array/src/scalar_fn/fns/mod.rs
index 734d06f7a48..b7cfda9224c 100644
--- a/vortex-array/src/scalar_fn/fns/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/mod.rs
@@ -3,6 +3,7 @@
 
 pub mod between;
 pub mod binary;
+pub mod byte_length;
 pub mod case_when;
 pub mod cast;
 pub mod dynamic;
diff --git a/vortex-array/src/scalar_fn/fns/not/mod.rs b/vortex-array/src/scalar_fn/fns/not/mod.rs
index 4e82d75e790..156a6568df7 100644
--- a/vortex-array/src/scalar_fn/fns/not/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/not/mod.rs
@@ -7,6 +7,7 @@ pub use kernel::*;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
@@ -33,7 +34,8 @@ impl ScalarFnVTable for Not {
     type Options = EmptyOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.not")
+        static ID: CachedId = CachedId::new("vortex.not");
+        *ID
     }
 
     fn serialize(&self, _options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
diff --git a/vortex-array/src/scalar_fn/fns/pack.rs b/vortex-array/src/scalar_fn/fns/pack.rs
index 0a24f721064..2a87bf069bc 100644
--- a/vortex-array/src/scalar_fn/fns/pack.rs
+++ b/vortex-array/src/scalar_fn/fns/pack.rs
@@ -11,6 +11,7 @@ use prost::Message;
 use vortex_error::VortexResult;
 use vortex_proto::expr as pb;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
@@ -55,7 +56,8 @@ impl ScalarFnVTable for Pack {
     type Options = PackOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::from("vortex.pack")
+        static ID: CachedId = CachedId::new("vortex.pack");
+        *ID
     }
 
     fn serialize(&self, instance: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
diff --git a/vortex-array/src/scalar_fn/fns/root.rs b/vortex-array/src/scalar_fn/fns/root.rs
index 99bb6fecf6e..87b8b62ccf4 100644
--- a/vortex-array/src/scalar_fn/fns/root.rs
+++ b/vortex-array/src/scalar_fn/fns/root.rs
@@ -6,6 +6,7 @@ use std::fmt::Formatter;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
@@ -30,7 +31,8 @@ impl ScalarFnVTable for Root {
     type Options = EmptyOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.root")
+        static ID: CachedId = CachedId::new("vortex.root");
+        *ID
     }
 
     fn serialize(&self, _instance: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
diff --git a/vortex-array/src/scalar_fn/fns/select.rs b/vortex-array/src/scalar_fn/fns/select.rs
index 2ca070c2bc4..54b63a00f89 100644
--- a/vortex-array/src/scalar_fn/fns/select.rs
+++ b/vortex-array/src/scalar_fn/fns/select.rs
@@ -14,6 +14,7 @@ use vortex_proto::expr::FieldNames as ProtoFieldNames;
 use vortex_proto::expr::SelectOpts;
 use vortex_proto::expr::select_opts::Opts;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
@@ -48,7 +49,8 @@ impl ScalarFnVTable for Select {
     type Options = FieldSelection;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::from("vortex.select")
+        static ID: CachedId = CachedId::new("vortex.select");
+        *ID
     }
 
     fn serialize(&self, instance: &FieldSelection) -> VortexResult<Option<Vec<u8>>> {
diff --git a/vortex-array/src/scalar_fn/fns/stat.rs b/vortex-array/src/scalar_fn/fns/stat.rs
index ae07ba16c60..84fc5760495 100644
--- a/vortex-array/src/scalar_fn/fns/stat.rs
+++ b/vortex-array/src/scalar_fn/fns/stat.rs
@@ -8,6 +8,7 @@ use std::fmt::Formatter;
 
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
+use vortex_session::registry::CachedId;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
@@ -82,7 +83,8 @@ impl ScalarFnVTable for StatFn {
     type Options = StatOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.stat")
+        static ID: CachedId = CachedId::new("vortex.stat");
+        *ID
     }
 
     fn arity(&self, _options: &Self::Options) -> Arity {
diff --git a/vortex-array/src/scalar_fn/fns/variant_get/mod.rs b/vortex-array/src/scalar_fn/fns/variant_get/mod.rs
index 1f09c819d94..ac6aa562aa6 100644
--- a/vortex-array/src/scalar_fn/fns/variant_get/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/variant_get/mod.rs
@@ -12,6 +12,7 @@ use vortex_error::vortex_err;
 use vortex_proto::expr as pb;
 use vortex_proto::expr::variant_path_element;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 use vortex_utils::aliases::StringEscape;
 
 use crate::ArrayRef;
@@ -45,7 +46,8 @@ impl ScalarFnVTable for VariantGet {
     type Options = VariantGetOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.variant_get")
+        static ID: CachedId = CachedId::new("vortex.variant_get");
+        *ID
     }
 
     fn serialize(&self, options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
diff --git a/vortex-array/src/scalar_fn/fns/zip/mod.rs b/vortex-array/src/scalar_fn/fns/zip/mod.rs
index 86b5c4f7dc1..8a3e1b5bbc6 100644
--- a/vortex-array/src/scalar_fn/fns/zip/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/zip/mod.rs
@@ -12,6 +12,7 @@ use vortex_error::vortex_ensure;
 use vortex_mask::Mask;
 use vortex_mask::MaskValues;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
@@ -31,6 +32,7 @@ use crate::scalar_fn::ScalarFnId;
 use crate::scalar_fn::ScalarFnVTable;
 use crate::scalar_fn::SimplifyCtx;
 use crate::scalar_fn::fns::literal::Literal;
+use crate::validity::Validity;
 
 /// An expression that conditionally selects between two arrays based on a boolean mask.
 ///
@@ -46,7 +48,8 @@ impl ScalarFnVTable for Zip {
     type Options = EmptyOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.zip")
+        static ID: CachedId = CachedId::new("vortex.zip");
+        *ID
     }
 
     fn serialize(&self, _options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
@@ -90,20 +93,12 @@ impl ScalarFnVTable for Zip {
     }
 
     fn return_dtype(&self, _options: &Self::Options, arg_dtypes: &[DType]) -> VortexResult<DType> {
-        vortex_ensure!(
-            arg_dtypes[0].eq_ignore_nullability(&arg_dtypes[1]),
-            "zip requires if_true and if_false to have the same base type, got {} and {}",
-            arg_dtypes[0],
-            arg_dtypes[1]
-        );
         vortex_ensure!(
             matches!(arg_dtypes[2], DType::Bool(_)),
             "zip requires mask to be a boolean type, got {}",
             arg_dtypes[2]
         );
-        Ok(arg_dtypes[0]
-            .clone()
-            .union_nullability(arg_dtypes[1].nullability()))
+        zip_return_dtype(&arg_dtypes[0], &arg_dtypes[1])
     }
 
     fn execute(
@@ -120,10 +115,7 @@ impl ScalarFnVTable for Zip {
             .execute::<BoolArray>(ctx)?
             .to_mask_fill_null_false(ctx);
 
-        let return_dtype = if_true
-            .dtype()
-            .clone()
-            .union_nullability(if_false.dtype().nullability());
+        let return_dtype = zip_return_dtype(if_true.dtype(), if_false.dtype())?;
 
         if mask.all_true() {
             return if_true.cast(return_dtype)?.execute(ctx);
@@ -184,10 +176,7 @@ pub(crate) fn zip_impl(
         "zip requires arrays to have the same size"
     );
 
-    let return_type = if_true
-        .dtype()
-        .clone()
-        .union_nullability(if_false.dtype().nullability());
+    let return_type = zip_return_dtype(if_true.dtype(), if_false.dtype())?;
 
     if mask.all_true() {
         return if_true.cast(return_type);
@@ -211,6 +200,18 @@ pub(crate) fn zip_impl(
     )
 }
 
+fn zip_return_dtype(if_true: &DType, if_false: &DType) -> VortexResult<DType> {
+    vortex_ensure!(
+        if_true.eq_ignore_nullability(if_false),
+        "zip requires if_true and if_false to have the same base type, got {} and {}",
+        if_true,
+        if_false
+    );
+    Ok(if_true
+        .least_supertype(if_false)
+        .vortex_expect("zip inputs with the same base type must have a common dtype"))
+}
+
 fn zip_impl_with_builder(
     if_true: &ArrayRef,
     if_false: &ArrayRef,
@@ -236,6 +237,34 @@ fn zip_impl_with_builder(
     Ok(builder.finish())
 }
 
+/// Combine two validities for a row-wise zip: take `if_true`'s validity where `mask` is set and
+/// `if_false`'s where it is not.
+///
+/// That selection is itself a zip over the two boolean validity bitmaps, so it is built as a (lazy)
+/// zip array — reusing the zip machinery rather than re-deriving the mask algebra. Trivial cases
+/// where both sides' validity already agrees skip the zip. `mask` must already be null-filled so the
+/// selection matches the accompanying value selection. Shared by the per-encoding zip kernels (e.g.
+/// `Bool`, `Primitive`) that build their result directly.
+pub(crate) fn zip_validity(
+    if_true: Validity,
+    if_false: Validity,
+    mask: &Mask,
+) -> VortexResult<Validity> {
+    match (&if_true, &if_false) {
+        (Validity::NonNullable, Validity::NonNullable) => return Ok(Validity::NonNullable),
+        (Validity::AllValid, Validity::AllValid) => return Ok(Validity::AllValid),
+        (Validity::AllInvalid, Validity::AllInvalid) => return Ok(Validity::AllInvalid),
+        _ => {}
+    }
+
+    let len = mask.len();
+    let validity = mask
+        .clone()
+        .into_array()
+        .zip(if_true.to_array(len), if_false.to_array(len))?;
+    Ok(Validity::Array(validity))
+}
+
 #[cfg(test)]
 mod tests {
     use arrow_array::cast::AsArray;
diff --git a/vortex-array/src/scalar_fn/internal/row_count.rs b/vortex-array/src/scalar_fn/internal/row_count.rs
index ea349f2ddf8..eee838f803d 100644
--- a/vortex-array/src/scalar_fn/internal/row_count.rs
+++ b/vortex-array/src/scalar_fn/internal/row_count.rs
@@ -21,6 +21,7 @@ use vortex_array::scalar_fn::ScalarFnVTable;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
+use vortex_session::registry::CachedId;
 
 /// Zero-argument placeholder for the row count of the current evaluation scope.
 ///
@@ -48,7 +49,8 @@ impl ScalarFnVTable for RowCount {
     type Options = EmptyOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::from("vortex.row_count")
+        static ID: CachedId = CachedId::new("vortex.row_count");
+        *ID
     }
 
     fn arity(&self, _options: &Self::Options) -> Arity {
diff --git a/vortex-array/src/scalar_fn/typed.rs b/vortex-array/src/scalar_fn/typed.rs
index a2ef9549bff..fbfc8caace4 100644
--- a/vortex-array/src/scalar_fn/typed.rs
+++ b/vortex-array/src/scalar_fn/typed.rs
@@ -4,8 +4,10 @@
 //! Typed and inner representations of scalar functions.
 //!
 //! - [`ScalarFn<V>`]: The public typed wrapper, parameterized by a concrete [`ScalarFnVTable`].
-//! - [`ScalarFn<V>`]: The private inner struct that holds the vtable + options.
+//! - [`TypedScalarFnInstance<V>`]: The inner struct that holds the vtable + options.
 //! - [`DynScalarFn`]: The private sealed trait for type-erased dispatch (bound, options in self).
+//!
+//! [`ScalarFn<V>`]: crate::arrays::scalar_fn::ScalarFn
 
 use std::any::Any;
 use std::fmt;
@@ -71,7 +73,7 @@ impl<V: ScalarFnVTable> TypedScalarFnInstance<V> {
 
 /// An object-safe, sealed trait for bound scalar function dispatch.
 ///
-/// Options are stored inside the implementing [`ScalarFn<V>`], not passed externally.
+/// Options are stored inside the implementing [`ScalarFn<V>`](crate::arrays::scalar_fn::ScalarFn), not passed externally.
 /// This is the sole trait behind [`ScalarFnRef`]'s `Arc<dyn DynScalarFn>`.
 pub(super) trait DynScalarFn: 'static + Send + Sync + super::sealed::Sealed {
     fn as_any(&self) -> &dyn Any;
diff --git a/vortex-array/src/search_sorted.rs b/vortex-array/src/search_sorted.rs
index 14741652330..3db5215e049 100644
--- a/vortex-array/src/search_sorted.rs
+++ b/vortex-array/src/search_sorted.rs
@@ -103,10 +103,12 @@ pub trait IndexOrd<V> {
     /// For example, if self\[idx\] > elem, return Some(Greater).
     fn index_cmp(&self, idx: usize, elem: &V) -> VortexResult<Option<Ordering>>;
 
+    #[inline]
     fn index_lt(&self, idx: usize, elem: &V) -> VortexResult<bool> {
         Ok(matches!(self.index_cmp(idx, elem)?, Some(Less)))
     }
 
+    #[inline]
     fn index_le(&self, idx: usize, elem: &V) -> VortexResult<bool> {
         Ok(matches!(self.index_cmp(idx, elem)?, Some(Less | Equal)))
     }
@@ -132,6 +134,7 @@ pub trait IndexOrd<V> {
 /// |left |array\[i-1\] < value <= array\[i\]|
 /// |right|array\[i-1\] <= value < array\[i\]|
 pub trait SearchSorted<T> {
+    #[inline]
     fn search_sorted(&self, value: &T, side: SearchSortedSide) -> VortexResult<SearchResult>
     where
         Self: IndexOrd<T>,
@@ -180,6 +183,7 @@ impl<S, T> SearchSorted<T> for S
 where
     S: IndexOrd<T> + ?Sized,
 {
+    #[inline]
     fn search_sorted_by<
         F: FnMut(usize) -> VortexResult<Ordering>,
         N: FnMut(usize) -> VortexResult<Ordering>,
@@ -210,6 +214,7 @@ where
 }
 
 // Code adapted from Rust standard library slice::binary_search_by
+#[inline]
 fn search_sorted_side_idx<F: FnMut(usize) -> VortexResult<Ordering>>(
     mut find: F,
     from: usize,
@@ -237,7 +242,7 @@ fn search_sorted_side_idx<F: FnMut(usize) -> VortexResult<Ordering>>(
         // Binary search interacts poorly with branch prediction, so force
         // the compiler to use conditional moves if supported by the target
         // architecture.
-        base = if cmp == Greater { base } else { mid };
+        base = hint::select_unpredictable(cmp == Greater, base, mid);
 
         // This is imprecise in the case where `size` is odd and the
         // comparison returns Greater: the mid element still gets included
@@ -276,11 +281,13 @@ impl IndexOrd<Scalar> for ArrayRef {
 }
 
 impl<T: PartialOrd> IndexOrd<T> for [T] {
+    #[inline]
     fn index_cmp(&self, idx: usize, elem: &T) -> VortexResult<Option<Ordering>> {
         // SAFETY: Used in search_sorted_by same as the standard library. The search_sorted ensures idx is in bounds
         Ok(unsafe { self.get_unchecked(idx) }.partial_cmp(elem))
     }
 
+    #[inline]
     fn index_len(&self) -> usize {
         self.len()
     }
diff --git a/vortex-array/src/stats/rewrite.rs b/vortex-array/src/stats/rewrite.rs
index bf342a95cdd..52d354df1a0 100644
--- a/vortex-array/src/stats/rewrite.rs
+++ b/vortex-array/src/stats/rewrite.rs
@@ -23,18 +23,34 @@ pub(crate) use builtins::register_builtins;
 /// Shared reference to a stats rewrite rule.
 pub(crate) type StatsRewriteRuleRef = Arc<dyn StatsRewriteRule>;
 
-/// A plugin-provided rule that rewrites predicates into stats-backed proof expressions.
+/// A plugin-provided rule for predicates whose root scalar function matches this rule.
 ///
-/// A falsifier evaluates to `true` only when the original predicate is definitely false for the
-/// current stats scope. A satisfier evaluates to `true` only when the original predicate is
-/// definitely true for the current stats scope. Returning `None` means the rule cannot prove
-/// anything for the expression.
-#[allow(dead_code)]
+/// Rules do not produce expressions equivalent to `expr`. They produce optional sufficient
+/// conditions over stats for the current scope:
+///
+/// - a falsifier evaluating to `true` proves that `expr` is false for every row in the scope;
+/// - a satisfier evaluating to `true` proves that `expr` is true for every row in the scope.
+///
+/// Returning `None` means this rule cannot prove anything for the expression. A returned proof
+/// expression that evaluates to `false` or `null` is also inconclusive.
+///
+/// Multiple rules may be registered for the same scalar function. Their proofs are combined with
+/// `OR`, so every proof returned by an individual rule must be sound on its own.
+///
+/// `expr` is the full predicate expression whose root scalar function id is
+/// [`Self::scalar_fn_id`]. Use [`StatsRewriteCtx`] to resolve dtypes and recursively rewrite child
+/// predicates.
 pub(crate) trait StatsRewriteRule: Debug + Send + Sync + 'static {
-    /// The scalar function ID this rule applies to.
+    /// Returns the scalar function id handled by this rule.
     fn scalar_fn_id(&self) -> ScalarFnId;
 
-    /// Rewrite an expression into a stats-backed falsifier.
+    /// Returns a stats-backed proof that `expr` is false for the current scope.
+    ///
+    /// If the returned expression evaluates to `true` against the scope's stats, then `expr` is
+    /// guaranteed to be false for every row in that scope. A returned proof expression that
+    /// evaluates to `false` or `null` is inconclusive.
+    ///
+    /// Returns `Ok(None)` when this rule cannot construct a sound falsity proof for `expr`.
     fn falsify(
         &self,
         expr: &Expression,
@@ -45,7 +61,16 @@ pub(crate) trait StatsRewriteRule: Debug + Send + Sync + 'static {
         Ok(None)
     }
 
-    /// Rewrite an expression into a stats-backed satisfier.
+    /// Returns a stats-backed proof that `expr` is true for the current scope.
+    ///
+    /// If the returned expression evaluates to `true` against the scope's stats, then `expr` is
+    /// guaranteed to be true for every row in that scope. A returned proof expression that
+    /// evaluates to `false` or `null` is inconclusive.
+    ///
+    /// This is not the complement of [`Self::falsify`]; both methods are one-way proofs and may be
+    /// implemented independently.
+    ///
+    /// Returns `Ok(None)` when this rule cannot construct a sound truth proof for `expr`.
     fn satisfy(
         &self,
         expr: &Expression,
diff --git a/vortex-array/src/stats/rewrite/builtins.rs b/vortex-array/src/stats/rewrite/builtins.rs
index 3476c053ecf..2b7316c7d98 100644
--- a/vortex-array/src/stats/rewrite/builtins.rs
+++ b/vortex-array/src/stats/rewrite/builtins.rs
@@ -84,15 +84,15 @@ impl StatsRewriteRule for BinaryStatsRewrite {
 
         Ok(match operator {
             Operator::Eq => {
-                let left = min(lhs).zip(max(rhs)).map(|(a, b)| gt(a, b));
-                let right = min(rhs).zip(max(lhs)).map(|(a, b)| gt(a, b));
+                let left = min(lhs, ctx).zip(max(rhs, ctx)).map(|(a, b)| gt(a, b));
+                let right = min(rhs, ctx).zip(max(lhs, ctx)).map(|(a, b)| gt(a, b));
                 or_collect(left.into_iter().chain(right))
                     .map(|value_predicate| with_nan_predicate(ctx, lhs, rhs, value_predicate))
                     .transpose()?
             }
-            Operator::NotEq => min(lhs)
-                .zip(max(rhs))
-                .zip(max(lhs).zip(min(rhs)))
+            Operator::NotEq => min(lhs, ctx)
+                .zip(max(rhs, ctx))
+                .zip(max(lhs, ctx).zip(min(rhs, ctx)))
                 .map(|((min_lhs, max_rhs), (max_lhs, min_rhs))| {
                     with_nan_predicate(
                         ctx,
@@ -102,20 +102,20 @@ impl StatsRewriteRule for BinaryStatsRewrite {
                     )
                 })
                 .transpose()?,
-            Operator::Gt => max(lhs)
-                .zip(min(rhs))
+            Operator::Gt => max(lhs, ctx)
+                .zip(min(rhs, ctx))
                 .map(|(a, b)| with_nan_predicate(ctx, lhs, rhs, lt_eq(a, b)))
                 .transpose()?,
-            Operator::Gte => max(lhs)
-                .zip(min(rhs))
+            Operator::Gte => max(lhs, ctx)
+                .zip(min(rhs, ctx))
                 .map(|(a, b)| with_nan_predicate(ctx, lhs, rhs, lt(a, b)))
                 .transpose()?,
-            Operator::Lt => min(lhs)
-                .zip(max(rhs))
+            Operator::Lt => min(lhs, ctx)
+                .zip(max(rhs, ctx))
                 .map(|(a, b)| with_nan_predicate(ctx, lhs, rhs, gt_eq(a, b)))
                 .transpose()?,
-            Operator::Lte => min(lhs)
-                .zip(max(rhs))
+            Operator::Lte => min(lhs, ctx)
+                .zip(max(rhs, ctx))
                 .map(|(a, b)| with_nan_predicate(ctx, lhs, rhs, gt(a, b)))
                 .transpose()?,
             Operator::And => {
@@ -167,17 +167,17 @@ impl StatsRewriteRule for IsNullLegacyStatsRewrite {
     fn falsify(
         &self,
         expr: &Expression,
-        _ctx: &StatsRewriteCtx<'_>,
+        ctx: &StatsRewriteCtx<'_>,
     ) -> VortexResult<Option<Expression>> {
-        Ok(null_count(expr.child(0)).map(|null_count| eq(null_count, lit(0u64))))
+        Ok(null_count(expr.child(0), ctx).map(|null_count| eq(null_count, lit(0u64))))
     }
 
     fn satisfy(
         &self,
         expr: &Expression,
-        _ctx: &StatsRewriteCtx<'_>,
+        ctx: &StatsRewriteCtx<'_>,
     ) -> VortexResult<Option<Expression>> {
-        Ok(null_count(expr.child(0))
+        Ok(null_count(expr.child(0), ctx)
             .map(|null_count| eq(null_count, RowCount.new_expr(EmptyOptions, []))))
     }
 }
@@ -227,18 +227,18 @@ impl StatsRewriteRule for IsNotNullLegacyStatsRewrite {
     fn falsify(
         &self,
         expr: &Expression,
-        _ctx: &StatsRewriteCtx<'_>,
+        ctx: &StatsRewriteCtx<'_>,
     ) -> VortexResult<Option<Expression>> {
-        Ok(null_count(expr.child(0))
+        Ok(null_count(expr.child(0), ctx)
             .map(|null_count| eq(null_count, RowCount.new_expr(EmptyOptions, []))))
     }
 
     fn satisfy(
         &self,
         expr: &Expression,
-        _ctx: &StatsRewriteCtx<'_>,
+        ctx: &StatsRewriteCtx<'_>,
     ) -> VortexResult<Option<Expression>> {
-        Ok(null_count(expr.child(0)).map(|null_count| eq(null_count, lit(0u64))))
+        Ok(null_count(expr.child(0), ctx).map(|null_count| eq(null_count, lit(0u64))))
     }
 }
 
@@ -287,7 +287,7 @@ impl StatsRewriteRule for LikeStatsRewrite {
     fn falsify(
         &self,
         expr: &Expression,
-        _ctx: &StatsRewriteCtx<'_>,
+        ctx: &StatsRewriteCtx<'_>,
     ) -> VortexResult<Option<Expression>> {
         let like_options = expr.as_::<Like>();
         if like_options.negated || like_options.case_insensitive {
@@ -304,8 +304,8 @@ impl StatsRewriteRule for LikeStatsRewrite {
         let source = expr.child(0);
         Ok(match LikeVariant::from_str(pattern) {
             Some(LikeVariant::Exact(text)) => {
-                min(source)
-                    .zip(max(source))
+                min(source, ctx)
+                    .zip(max(source, ctx))
                     .map(|(source_min, source_max)| {
                         or(
                             gt(source_min, lit(text.as_ref())),
@@ -317,8 +317,8 @@ impl StatsRewriteRule for LikeStatsRewrite {
                 let Some(successor) = prefix.to_string().increment().ok() else {
                     return Ok(None);
                 };
-                min(source)
-                    .zip(max(source))
+                min(source, ctx)
+                    .zip(max(source, ctx))
                     .map(|(source_min, source_max)| {
                         or(
                             gt_eq(source_min, lit(successor)),
@@ -361,10 +361,10 @@ impl StatsRewriteRule for ListContainsStatsRewrite {
             return Ok(Some(lit(true)));
         }
 
-        let Some(value_max) = max(needle) else {
+        let Some(value_max) = max(needle, ctx) else {
             return Ok(None);
         };
-        let Some(value_min) = min(needle) else {
+        let Some(value_min) = min(needle, ctx) else {
             return Ok(None);
         };
 
@@ -398,10 +398,10 @@ impl StatsRewriteRule for DynamicComparisonStatsRewrite {
 
         let Some((operator, lhs_stat)) = (match dynamic.operator {
             CompareOperator::Eq | CompareOperator::NotEq => None,
-            CompareOperator::Gt => max(lhs).map(|lhs_stat| (CompareOperator::Lte, lhs_stat)),
-            CompareOperator::Gte => max(lhs).map(|lhs_stat| (CompareOperator::Lt, lhs_stat)),
-            CompareOperator::Lt => min(lhs).map(|lhs_stat| (CompareOperator::Gte, lhs_stat)),
-            CompareOperator::Lte => min(lhs).map(|lhs_stat| (CompareOperator::Gt, lhs_stat)),
+            CompareOperator::Gt => max(lhs, ctx).map(|lhs_stat| (CompareOperator::Lte, lhs_stat)),
+            CompareOperator::Gte => max(lhs, ctx).map(|lhs_stat| (CompareOperator::Lt, lhs_stat)),
+            CompareOperator::Lt => min(lhs, ctx).map(|lhs_stat| (CompareOperator::Gte, lhs_stat)),
+            CompareOperator::Lte => min(lhs, ctx).map(|lhs_stat| (CompareOperator::Gt, lhs_stat)),
         }) else {
             return Ok(None);
         };
@@ -418,16 +418,16 @@ impl StatsRewriteRule for DynamicComparisonStatsRewrite {
     }
 }
 
-fn min(expr: &Expression) -> Option<Expression> {
-    stat_expr(expr, Stat::Min)
+fn min(expr: &Expression, ctx: &StatsRewriteCtx<'_>) -> Option<Expression> {
+    stat_expr(expr, Stat::Min, ctx)
 }
 
-fn max(expr: &Expression) -> Option<Expression> {
-    stat_expr(expr, Stat::Max)
+fn max(expr: &Expression, ctx: &StatsRewriteCtx<'_>) -> Option<Expression> {
+    stat_expr(expr, Stat::Max, ctx)
 }
 
-fn null_count(expr: &Expression) -> Option<Expression> {
-    stat_expr(expr, Stat::NullCount)
+fn null_count(expr: &Expression, ctx: &StatsRewriteCtx<'_>) -> Option<Expression> {
+    stat_expr(expr, Stat::NullCount, ctx)
 }
 
 fn all_null(expr: &Expression) -> Expression {
@@ -474,7 +474,7 @@ fn has_nans(dtype: &DType) -> bool {
     matches!(dtype, DType::Primitive(ptype, _) if ptype.is_float())
 }
 
-fn stat_expr(expr: &Expression, stat: Stat) -> Option<Expression> {
+fn stat_expr(expr: &Expression, stat: Stat, ctx: &StatsRewriteCtx<'_>) -> Option<Expression> {
     if let Some(literal) = literal_stat(expr, stat) {
         return Some(literal);
     }
@@ -487,11 +487,18 @@ fn stat_expr(expr: &Expression, stat: Stat) -> Option<Expression> {
     }
 
     if let Some(dtype) = expr.as_opt::<Cast>() {
-        return cast_stat(expr.child(0), dtype, stat);
-    }
-
-    stat.aggregate_fn()
-        .map(|aggregate_fn| stat_fn(expr.clone(), aggregate_fn))
+        return cast_stat(expr.child(0), dtype, stat, ctx);
+    }
+
+    let aggregate_fn = stat.aggregate_fn()?;
+    // The aggregate may not support the expression's dtype, e.g. min/max over structs,
+    // even when the predicate itself is well-typed. Such stats cannot be lowered later,
+    // so do not reference them in the rewrite.
+    let input_dtype = ctx.return_dtype(expr).ok()?;
+    aggregate_fn
+        .return_dtype(&input_dtype)
+        .is_some()
+        .then(|| stat_fn(expr.clone(), aggregate_fn))
 }
 
 fn with_nan_predicate(
@@ -545,10 +552,15 @@ fn literal_stat(expr: &Expression, stat: Stat) -> Option<Expression> {
     }
 }
 
-fn cast_stat(expr: &Expression, dtype: &DType, stat: Stat) -> Option<Expression> {
+fn cast_stat(
+    expr: &Expression,
+    dtype: &DType,
+    stat: Stat,
+    ctx: &StatsRewriteCtx<'_>,
+) -> Option<Expression> {
     match stat {
-        Stat::Min | Stat::Max => stat_expr(expr, stat).map(|stat| cast(stat, dtype.clone())),
-        Stat::NaNCount | Stat::Sum | Stat::UncompressedSizeInBytes => stat_expr(expr, stat),
+        Stat::Min | Stat::Max => stat_expr(expr, stat, ctx).map(|stat| cast(stat, dtype.clone())),
+        Stat::NaNCount | Stat::Sum | Stat::UncompressedSizeInBytes => stat_expr(expr, stat, ctx),
         Stat::NullCount | Stat::IsConstant | Stat::IsSorted | Stat::IsStrictSorted => None,
     }
 }
@@ -626,11 +638,19 @@ mod tests {
                 ("f", DType::Primitive(PType::F32, Nullability::NonNullable)),
                 ("s", DType::Utf8(Nullability::NonNullable)),
                 ("t", DType::Utf8(Nullability::NonNullable)),
+                ("n", nested_struct_dtype()),
             ]),
             Nullability::NonNullable,
         )
     }
 
+    fn nested_struct_dtype() -> DType {
+        DType::Struct(
+            StructFields::from_iter([("x", DType::Primitive(PType::F32, Nullability::Nullable))]),
+            Nullability::NonNullable,
+        )
+    }
+
     fn falsify(expr: &Expression) -> VortexResult<Option<Expression>> {
         expr.falsify(&test_scope(), &SESSION)
     }
@@ -848,6 +868,19 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn skips_falsifier_when_min_max_unsupported_for_dtype() -> VortexResult<()> {
+        // Struct comparisons are valid predicates, but min/max aggregates do not
+        // support struct inputs, so no stats-backed falsifier should be produced.
+        let struct_scalar = Scalar::struct_(
+            nested_struct_dtype(),
+            vec![Scalar::primitive(1.0f32, Nullability::Nullable)],
+        );
+        assert_eq!(falsify(&lt_eq(col("n"), lit(struct_scalar.clone())))?, None);
+        assert_eq!(falsify(&eq(col("n"), lit(struct_scalar)))?, None);
+        Ok(())
+    }
+
     #[test]
     fn forwards_min_max_through_safe_cast() -> VortexResult<()> {
         let dtype = DType::Primitive(PType::I64, Nullability::NonNullable);
diff --git a/vortex-array/src/validity.rs b/vortex-array/src/validity.rs
index 204205d1f51..8d36c07405e 100644
--- a/vortex-array/src/validity.rs
+++ b/vortex-array/src/validity.rs
@@ -112,13 +112,30 @@ impl Validity {
         }
     }
 
-    /// Returns `true` if this validity guarantees no null values, i.e. it is either
+    /// Returns `true` if this validity *definitely* contains no null values, i.e. it is either
     /// [`Validity::NonNullable`] or [`Validity::AllValid`].
+    ///
+    /// Returning `false` does not prove the presence of nulls: a [`Validity::Array`] may still
+    /// resolve to all-valid once executed. Callers must treat `false` as "unknown without
+    /// compute" and either fall back to a null-handling path or execute the validity.
     #[inline]
-    pub fn no_nulls(&self) -> bool {
+    pub fn definitely_no_nulls(&self) -> bool {
         matches!(self, Self::NonNullable | Self::AllValid)
     }
 
+    /// Returns whether this validity contains no null values, executing the validity array if
+    /// necessary.
+    ///
+    /// This is the exact counterpart to [`Self::definitely_no_nulls`]: use it when the caller
+    /// needs a definitive answer rather than a cheap, conservative one.
+    pub fn execute_no_nulls(&self, length: usize, ctx: &mut ExecutionCtx) -> VortexResult<bool> {
+        match self {
+            Self::NonNullable | Self::AllValid => Ok(true),
+            Self::AllInvalid => Ok(length == 0),
+            Self::Array(_) => Ok(self.execute_mask(length, ctx)?.all_true()),
+        }
+    }
+
     /// The union nullability and validity.
     #[inline]
     pub fn union_nullability(self, nullability: Nullability) -> Self {
@@ -128,24 +145,38 @@ impl Validity {
         }
     }
 
-    /// Returns whether the `index` item is valid.
+    /// Returns whether the `index` item is valid, using `ctx` to execute the validity array.
     #[inline]
-    pub fn is_valid(&self, index: usize) -> VortexResult<bool> {
+    pub fn execute_is_valid(&self, index: usize, ctx: &mut ExecutionCtx) -> VortexResult<bool> {
         Ok(match self {
             Self::NonNullable | Self::AllValid => true,
             Self::AllInvalid => false,
             Self::Array(a) => a
-                .execute_scalar(index, &mut LEGACY_SESSION.create_execution_ctx())
-                .vortex_expect("Validity array must support execute_scalar")
+                .execute_scalar(index, ctx)?
                 .as_bool()
                 .value()
-                .vortex_expect("Validity must be non-nullable"),
+                .ok_or_else(|| vortex_err!("validity value at index {index} is null"))?,
         })
     }
 
+    /// Returns whether the `index` item is null, using `ctx` to execute the validity array.
+    #[inline]
+    pub fn execute_is_null(&self, index: usize, ctx: &mut ExecutionCtx) -> VortexResult<bool> {
+        Ok(!self.execute_is_valid(index, ctx)?)
+    }
+
+    /// Returns whether the `index` item is valid.
+    #[deprecated(note = "use `execute_is_valid` with an explicit `ExecutionCtx`")]
+    #[inline]
+    pub fn is_valid(&self, index: usize) -> VortexResult<bool> {
+        self.execute_is_valid(index, &mut LEGACY_SESSION.create_execution_ctx())
+    }
+
+    /// Returns whether the `index` item is null.
+    #[deprecated(note = "use `execute_is_null` with an explicit `ExecutionCtx`")]
     #[inline]
     pub fn is_null(&self, index: usize) -> VortexResult<bool> {
-        Ok(!self.is_valid(index)?)
+        self.execute_is_null(index, &mut LEGACY_SESSION.create_execution_ctx())
     }
 
     #[inline]
@@ -213,6 +244,7 @@ impl Validity {
         }
     }
 
+    #[inline]
     pub fn execute_mask(&self, length: usize, ctx: &mut ExecutionCtx) -> VortexResult<Mask> {
         match self {
             Self::NonNullable | Self::AllValid => Ok(Mask::AllTrue(length)),
@@ -232,18 +264,22 @@ impl Validity {
         }
     }
 
-    /// Compare two Validity values of the same length by executing them into masks if necessary.
-    pub fn mask_eq(&self, other: &Validity, ctx: &mut ExecutionCtx) -> VortexResult<bool> {
+    /// Compare the logical masks of two Validity values of the given length, executing them
+    /// into [`Mask`]s if necessary.
+    pub fn mask_eq(
+        &self,
+        other: &Validity,
+        length: usize,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<bool> {
         match (self, other) {
-            (Validity::NonNullable, Validity::NonNullable) => Ok(true),
-            (Validity::AllValid, Validity::AllValid) => Ok(true),
-            (Validity::AllInvalid, Validity::AllInvalid) => Ok(true),
-            (Validity::Array(a), Validity::Array(b)) => {
-                let a = a.clone().execute::<Mask>(ctx)?;
-                let b = b.clone().execute::<Mask>(ctx)?;
-                Ok(a == b)
-            }
-            _ => Ok(false),
+            // Fast paths that avoid executing: constant variants with known-equal masks.
+            (
+                Validity::NonNullable | Validity::AllValid,
+                Validity::NonNullable | Validity::AllValid,
+            )
+            | (Validity::AllInvalid, Validity::AllInvalid) => Ok(true),
+            _ => Ok(self.execute_mask(length, ctx)? == other.execute_mask(length, ctx)?),
         }
     }
 
@@ -672,7 +708,7 @@ mod tests {
             validity
                 .patch(len, 0, &indices, &patches, &mut ctx,)
                 .unwrap()
-                .mask_eq(&expected, &mut ctx)
+                .mask_eq(&expected, len, &mut ctx)
                 .unwrap()
         );
     }
@@ -737,8 +773,50 @@ mod tests {
             validity
                 .take(&indices)
                 .unwrap()
-                .mask_eq(&expected, &mut ctx)
+                .mask_eq(&expected, indices.len(), &mut ctx)
                 .unwrap()
         );
     }
+
+    #[rstest]
+    // Mixed constant variants with equal masks.
+    #[case(Validity::NonNullable, Validity::AllValid, true)]
+    #[case(Validity::AllValid, Validity::NonNullable, true)]
+    #[case(Validity::AllValid, Validity::AllInvalid, false)]
+    #[case(Validity::NonNullable, Validity::AllInvalid, false)]
+    // An array that resolves to a constant mask must equal the constant variant.
+    #[case(
+        Validity::Array(BoolArray::from_iter([true, true, true]).into_array()),
+        Validity::AllValid,
+        true
+    )]
+    #[case(
+        Validity::NonNullable,
+        Validity::Array(BoolArray::from_iter([true, true, true]).into_array()),
+        true
+    )]
+    #[case(
+        Validity::Array(BoolArray::from_iter([false, false, false]).into_array()),
+        Validity::AllInvalid,
+        true
+    )]
+    #[case(
+        Validity::Array(BoolArray::from_iter([true, false, true]).into_array()),
+        Validity::AllValid,
+        false
+    )]
+    #[case(
+        Validity::Array(BoolArray::from_iter([true, false, true]).into_array()),
+        Validity::AllInvalid,
+        false
+    )]
+    fn mask_eq_mixed_variants(
+        #[case] lhs: Validity,
+        #[case] rhs: Validity,
+        #[case] expected: bool,
+    ) -> vortex_error::VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        assert_eq!(lhs.mask_eq(&rhs, 3, &mut ctx)?, expected);
+        Ok(())
+    }
 }
diff --git a/vortex-array/src/variants.rs b/vortex-array/src/variants.rs
index ca64d1ccffb..2bc1f7fecfd 100644
--- a/vortex-array/src/variants.rs
+++ b/vortex-array/src/variants.rs
@@ -112,6 +112,9 @@ pub struct NullTyped<'a>(&'a ArrayRef);
 pub struct BoolTyped<'a>(&'a ArrayRef);
 
 impl BoolTyped<'_> {
+    #[deprecated(
+        note = "Relies on the hidden global `LEGACY_SESSION`; use `sum(array, ctx)` with an explicit `ExecutionCtx` instead"
+    )]
     pub fn true_count(&self) -> VortexResult<usize> {
         let mut ctx = LEGACY_SESSION.create_execution_ctx();
         let true_count = sum(self.0, &mut ctx)?;
@@ -133,6 +136,10 @@ impl PrimitiveTyped<'_> {
     }
 
     /// Return the primitive value at the given index.
+    #[deprecated(
+        note = "Relies on the hidden global `LEGACY_SESSION`; use `is_valid`/`execute_scalar` with an explicit `ExecutionCtx` instead"
+    )]
+    #[allow(deprecated)]
     pub fn value(&self, idx: usize) -> VortexResult<Option<PValue>> {
         self.0
             .is_valid(idx, &mut LEGACY_SESSION.create_execution_ctx())?
@@ -141,6 +148,9 @@ impl PrimitiveTyped<'_> {
     }
 
     /// Return the primitive value at the given index, ignoring nullability.
+    #[deprecated(
+        note = "Relies on the hidden global `LEGACY_SESSION`; use `execute_scalar` with an explicit `ExecutionCtx` instead"
+    )]
     pub fn value_unchecked(&self, idx: usize) -> VortexResult<PValue> {
         Ok(self
             .0
@@ -152,6 +162,7 @@ impl PrimitiveTyped<'_> {
 }
 
 impl IndexOrd<Option<PValue>> for PrimitiveTyped<'_> {
+    #[allow(deprecated)]
     fn index_cmp(&self, idx: usize, elem: &Option<PValue>) -> VortexResult<Option<Ordering>> {
         let value = self.value(idx)?;
         Ok(value.partial_cmp(elem))
@@ -164,6 +175,7 @@ impl IndexOrd<Option<PValue>> for PrimitiveTyped<'_> {
 
 // TODO(ngates): add generics to the `value` function and implement this over T.
 impl IndexOrd<PValue> for PrimitiveTyped<'_> {
+    #[allow(deprecated)]
     fn index_cmp(&self, idx: usize, elem: &PValue) -> VortexResult<Option<Ordering>> {
         assert!(
             self.0
diff --git a/vortex-bench/Cargo.toml b/vortex-bench/Cargo.toml
index fc1766c599f..3b793c6124a 100644
--- a/vortex-bench/Cargo.toml
+++ b/vortex-bench/Cargo.toml
@@ -30,7 +30,6 @@ arrow-array = { workspace = true }
 arrow-schema = { workspace = true }
 arrow-select = { workspace = true }
 async-trait = { workspace = true }
-bytes = { workspace = true }
 bzip2 = { workspace = true }
 clap = { workspace = true, features = ["derive"] }
 futures = { workspace = true }
diff --git a/vortex-bench/clickbench_queries.sql b/vortex-bench/clickbench_queries.sql
index 0c30150ef69..6e98b0b737a 100644
--- a/vortex-bench/clickbench_queries.sql
+++ b/vortex-bench/clickbench_queries.sql
@@ -25,8 +25,8 @@ SELECT * FROM hits WHERE "URL" LIKE '%google%' ORDER BY "EventTime" LIMIT 10;
 SELECT "SearchPhrase" FROM hits WHERE "SearchPhrase" <> '' ORDER BY "EventTime" LIMIT 10;
 SELECT "SearchPhrase" FROM hits WHERE "SearchPhrase" <> '' ORDER BY "SearchPhrase" LIMIT 10;
 SELECT "SearchPhrase" FROM hits WHERE "SearchPhrase" <> '' ORDER BY "EventTime", "SearchPhrase" LIMIT 10;
-SELECT "CounterID", AVG(length("URL")) AS l, COUNT(*) AS c FROM hits WHERE "URL" <> '' GROUP BY "CounterID" HAVING COUNT(*) > 100000 ORDER BY l DESC LIMIT 25;
-SELECT REGEXP_REPLACE("Referer", '^https?://(?:www\.)?([^/]+)/.*$', '\1') AS k, AVG(length("Referer")) AS l, COUNT(*) AS c, MIN("Referer") FROM hits WHERE "Referer" <> '' GROUP BY k HAVING COUNT(*) > 100000 ORDER BY l DESC LIMIT 25;
+SELECT "CounterID", AVG(OCTET_LENGTH("URL")) AS l, COUNT(*) AS c FROM hits WHERE "URL" <> '' GROUP BY "CounterID" HAVING COUNT(*) > 100000 ORDER BY l DESC LIMIT 25; -- ClickHouse's length counts bytes, not code points as standard SQL.
+SELECT REGEXP_REPLACE("Referer", '^https?://(?:www\.)?([^/]+)/.*$', '\1') AS k, AVG(OCTET_LENGTH("Referer")) AS l, COUNT(*) AS c, MIN("Referer") FROM hits WHERE "Referer" <> '' GROUP BY k HAVING COUNT(*) > 100000 ORDER BY l DESC LIMIT 25; -- ClickHouse's length counts bytes, not code points as standard SQL.
 SELECT SUM("ResolutionWidth"), SUM("ResolutionWidth" + 1), SUM("ResolutionWidth" + 2), SUM("ResolutionWidth" + 3), SUM("ResolutionWidth" + 4), SUM("ResolutionWidth" + 5), SUM("ResolutionWidth" + 6), SUM("ResolutionWidth" + 7), SUM("ResolutionWidth" + 8), SUM("ResolutionWidth" + 9), SUM("ResolutionWidth" + 10), SUM("ResolutionWidth" + 11), SUM("ResolutionWidth" + 12), SUM("ResolutionWidth" + 13), SUM("ResolutionWidth" + 14), SUM("ResolutionWidth" + 15), SUM("ResolutionWidth" + 16), SUM("ResolutionWidth" + 17), SUM("ResolutionWidth" + 18), SUM("ResolutionWidth" + 19), SUM("ResolutionWidth" + 20), SUM("ResolutionWidth" + 21), SUM("ResolutionWidth" + 22), SUM("ResolutionWidth" + 23), SUM("ResolutionWidth" + 24), SUM("ResolutionWidth" + 25), SUM("ResolutionWidth" + 26), SUM("ResolutionWidth" + 27), SUM("ResolutionWidth" + 28), SUM("ResolutionWidth" + 29), SUM("ResolutionWidth" + 30), SUM("ResolutionWidth" + 31), SUM("ResolutionWidth" + 32), SUM("ResolutionWidth" + 33), SUM("ResolutionWidth" + 34), SUM("ResolutionWidth" + 35), SUM("ResolutionWidth" + 36), SUM("ResolutionWidth" + 37), SUM("ResolutionWidth" + 38), SUM("ResolutionWidth" + 39), SUM("ResolutionWidth" + 40), SUM("ResolutionWidth" + 41), SUM("ResolutionWidth" + 42), SUM("ResolutionWidth" + 43), SUM("ResolutionWidth" + 44), SUM("ResolutionWidth" + 45), SUM("ResolutionWidth" + 46), SUM("ResolutionWidth" + 47), SUM("ResolutionWidth" + 48), SUM("ResolutionWidth" + 49), SUM("ResolutionWidth" + 50), SUM("ResolutionWidth" + 51), SUM("ResolutionWidth" + 52), SUM("ResolutionWidth" + 53), SUM("ResolutionWidth" + 54), SUM("ResolutionWidth" + 55), SUM("ResolutionWidth" + 56), SUM("ResolutionWidth" + 57), SUM("ResolutionWidth" + 58), SUM("ResolutionWidth" + 59), SUM("ResolutionWidth" + 60), SUM("ResolutionWidth" + 61), SUM("ResolutionWidth" + 62), SUM("ResolutionWidth" + 63), SUM("ResolutionWidth" + 64), SUM("ResolutionWidth" + 65), SUM("ResolutionWidth" + 66), SUM("ResolutionWidth" + 67), SUM("ResolutionWidth" + 68), SUM("ResolutionWidth" + 69), SUM("ResolutionWidth" + 70), SUM("ResolutionWidth" + 71), SUM("ResolutionWidth" + 72), SUM("ResolutionWidth" + 73), SUM("ResolutionWidth" + 74), SUM("ResolutionWidth" + 75), SUM("ResolutionWidth" + 76), SUM("ResolutionWidth" + 77), SUM("ResolutionWidth" + 78), SUM("ResolutionWidth" + 79), SUM("ResolutionWidth" + 80), SUM("ResolutionWidth" + 81), SUM("ResolutionWidth" + 82), SUM("ResolutionWidth" + 83), SUM("ResolutionWidth" + 84), SUM("ResolutionWidth" + 85), SUM("ResolutionWidth" + 86), SUM("ResolutionWidth" + 87), SUM("ResolutionWidth" + 88), SUM("ResolutionWidth" + 89) FROM hits;
 SELECT "SearchEngineID", "ClientIP", COUNT(*) AS c, SUM("IsRefresh"), AVG("ResolutionWidth") FROM hits WHERE "SearchPhrase" <> '' GROUP BY "SearchEngineID", "ClientIP" ORDER BY c DESC LIMIT 10;
 SELECT "WatchID", "ClientIP", COUNT(*) AS c, SUM("IsRefresh"), AVG("ResolutionWidth") FROM hits WHERE "SearchPhrase" <> '' GROUP BY "WatchID", "ClientIP" ORDER BY c DESC LIMIT 10;
diff --git a/vortex-bench/src/compress/mod.rs b/vortex-bench/src/compress/mod.rs
index 87336ab0768..6e261b871d2 100644
--- a/vortex-bench/src/compress/mod.rs
+++ b/vortex-bench/src/compress/mod.rs
@@ -16,6 +16,31 @@ use crate::Format;
 use crate::measurements::CompressionTimingMeasurement;
 use crate::measurements::CustomUnitMeasurement;
 
+/// Number of top-level columns in the wide-table decompression projection benchmark.
+pub const READ_PROJECTION_ROOT_COLUMNS: usize = 100_000;
+
+/// Number of top-level columns read by the wide-table decompression projection benchmark.
+pub const READ_PROJECTION_COLUMNS: usize = 10_000;
+
+/// Fixed read projection for the wide-table decompression projection benchmark.
+pub static READ_PROJECTION: [usize; READ_PROJECTION_COLUMNS] = make_read_projection();
+
+const fn make_read_projection() -> [usize; READ_PROJECTION_COLUMNS] {
+    let stride = READ_PROJECTION_ROOT_COLUMNS / READ_PROJECTION_COLUMNS;
+    let mut projection = [0; READ_PROJECTION_COLUMNS];
+    let mut idx = 0;
+    while idx < READ_PROJECTION_COLUMNS {
+        projection[idx] = idx * stride;
+        idx += 1;
+    }
+    projection
+}
+
+/// Read projection for a file with `root_columns` top-level columns, if this benchmark projects it.
+pub fn read_projection(root_columns: usize) -> Option<&'static [usize]> {
+    (root_columns == READ_PROJECTION_ROOT_COLUMNS).then_some(&READ_PROJECTION)
+}
+
 #[derive(Default)]
 pub struct CompressMeasurements {
     pub timings: Vec<CompressionTimingMeasurement>,
@@ -100,6 +125,9 @@ pub trait Compressor: Send + Sync {
     ///
     /// This method first compresses the data to the target format, then decompresses it.
     /// The timing returned should only measure the decompression phase.
+    ///
+    /// Format implementations apply the fixed wide-table read projection when the input schema
+    /// matches the projection benchmark.
     async fn decompress(&self, parquet_path: &Path) -> Result<Duration>;
 }
 
diff --git a/vortex-bench/src/datasets/struct_list_of_ints.rs b/vortex-bench/src/datasets/struct_list_of_ints.rs
index 7ca16636f8f..fe9aa991681 100644
--- a/vortex-bench/src/datasets/struct_list_of_ints.rs
+++ b/vortex-bench/src/datasets/struct_list_of_ints.rs
@@ -16,7 +16,6 @@ use rand::rngs::StdRng;
 use vortex::array::ArrayRef;
 use vortex::array::ExecutionCtx;
 use vortex::array::IntoArray;
-use vortex::array::LEGACY_SESSION;
 use vortex::array::VortexSessionExecute;
 use vortex::array::arrays::Chunked;
 use vortex::array::arrays::ChunkedArray;
@@ -30,6 +29,7 @@ use vortex::array::validity::Validity;
 use vortex::dtype::FieldNames;
 
 use crate::IdempotentPath;
+use crate::SESSION;
 use crate::datasets::Dataset;
 use crate::idempotent_async;
 
@@ -44,11 +44,26 @@ pub struct StructListOfInts {
 
 impl StructListOfInts {
     pub fn new(num_columns: usize, row_count: usize, chunk_count: usize) -> Self {
+        Self::new_with_projection(num_columns, row_count, chunk_count, None)
+    }
+
+    /// Like [`StructListOfInts::new`], but names the dataset for a projected decompress benchmark.
+    pub fn new_with_projection(
+        num_columns: usize,
+        row_count: usize,
+        chunk_count: usize,
+        project_columns: Option<usize>,
+    ) -> Self {
+        let mut name =
+            format!("wide table cols={num_columns} chunks={chunk_count} rows={row_count}");
+        if let Some(count) = project_columns {
+            name.push_str(&format!(" project={count}"));
+        }
         Self {
             num_columns,
             row_count,
             chunk_count,
-            name: format!("wide table cols={num_columns} chunks={chunk_count} rows={row_count}"),
+            name,
         }
     }
 }
@@ -120,7 +135,7 @@ impl Dataset for StructListOfInts {
 
         idempotent_async(&parquet_path, |temp_path| async move {
             // Generate the data
-            let mut ctx = LEGACY_SESSION.create_execution_ctx();
+            let mut ctx = SESSION.create_execution_ctx();
             let array = self.to_vortex_array(&mut ctx).await?;
 
             // Convert to Arrow RecordBatches and write to parquet
@@ -130,14 +145,12 @@ impl Dataset for StructListOfInts {
             let mut writer: Option<ArrowWriter<File>> = None;
 
             for chunk in chunked.iter_chunks() {
-                let converted = recursive_list_from_list_view(chunk.clone())?;
+                let converted = recursive_list_from_list_view(chunk.clone(), &mut ctx)?;
                 let schema = converted.dtype().to_arrow_schema()?;
                 let schema = Field::new_struct("", schema.fields, false);
-                let batch = LEGACY_SESSION.arrow().execute_arrow(
-                    converted,
-                    Some(&schema),
-                    &mut LEGACY_SESSION.create_execution_ctx(),
-                )?;
+                let batch = SESSION
+                    .arrow()
+                    .execute_arrow(converted, Some(&schema), &mut ctx)?;
                 let batch = RecordBatch::from(batch.as_struct());
 
                 if writer.is_none() {
diff --git a/vortex-bench/src/random_access/take.rs b/vortex-bench/src/random_access/take.rs
index 147a8cf347e..e86e5d576d6 100644
--- a/vortex-bench/src/random_access/take.rs
+++ b/vortex-bench/src/random_access/take.rs
@@ -48,7 +48,11 @@ impl VortexRandomAccessor {
         name: impl Into<String>,
         format: Format,
     ) -> anyhow::Result<Self> {
-        let file = SESSION.open_options().open_path(path.as_ref()).await?;
+        let file = SESSION
+            .open_options()
+            .with_layout_reader_cache()
+            .open_path(path.as_ref())
+            .await?;
         Ok(Self {
             name: name.into(),
             format,
diff --git a/vortex-bench/src/v3.rs b/vortex-bench/src/v3.rs
index 7e7a3e2a553..48e8a7f1c94 100644
--- a/vortex-bench/src/v3.rs
+++ b/vortex-bench/src/v3.rs
@@ -498,7 +498,7 @@ pub fn write_jsonl_to_path(path: &std::path::Path, records: &[V3Record]) -> std:
 /// value the server-side `value_ns: i64` deserializer can accept.
 ///
 /// The wire field is `u64` (see `value_ns` on every record type below),
-/// but the server's [`vortex_bench_server::records`] mirrors them as `i64`.
+/// but the server's records mirrors them as `i64`.
 /// Without the clamp, an overflowed measurement would land at `u64::MAX`
 /// here, fail serde deserialization on the server, and 400 the whole
 /// ingest envelope.
diff --git a/vortex-bench/src/vector_dataset/convert.rs b/vortex-bench/src/vector_dataset/convert.rs
index f0c13ff33aa..a0125bd923b 100644
--- a/vortex-bench/src/vector_dataset/convert.rs
+++ b/vortex-bench/src/vector_dataset/convert.rs
@@ -4,7 +4,9 @@
 // TODO(connor): Should we re-export this through `conversions.rs`?
 
 use vortex::array::ArrayRef;
+use vortex::array::EmptyMetadata;
 use vortex::array::IntoArray;
+use vortex::array::VortexSessionExecute;
 use vortex::array::arrays::Chunked;
 use vortex::array::arrays::ChunkedArray;
 use vortex::array::arrays::ExtensionArray;
@@ -23,9 +25,10 @@ use vortex::error::VortexExpect;
 use vortex::error::VortexResult;
 use vortex::error::vortex_bail;
 use vortex::error::vortex_err;
-use vortex::extension::EmptyMetadata;
 use vortex_tensor::vector::Vector;
 
+use crate::SESSION;
+
 /// Rewrap a list-of-float column as a [`vortex_tensor::vector::Vector`] extension array.
 ///
 /// Parquet has no fixed-size list logical type, so an embedding column ingested via
@@ -75,7 +78,7 @@ pub fn list_to_vector_ext(input: ArrayRef) -> VortexResult<ArrayRef> {
     // `parquet_to_vortex_chunks` produces `ListView` arrays for list columns by default;
     // materialize them into a flat `List` representation before we validate offsets.
     if input.as_opt::<ListView>().is_some() {
-        let flat = recursive_list_from_list_view(input)?;
+        let flat = recursive_list_from_list_view(input, &mut SESSION.create_execution_ctx())?;
         return list_to_vector_ext(flat);
     }
 
diff --git a/vortex-btrblocks/Cargo.toml b/vortex-btrblocks/Cargo.toml
index 1adb6508828..34a98f85b73 100644
--- a/vortex-btrblocks/Cargo.toml
+++ b/vortex-btrblocks/Cargo.toml
@@ -18,8 +18,6 @@ itertools = { workspace = true }
 num-traits = { workspace = true }
 pco = { workspace = true, optional = true }
 rand = { workspace = true }
-rustc-hash = { workspace = true }
-tracing = { workspace = true }
 vortex-alp = { workspace = true }
 vortex-array = { workspace = true }
 vortex-buffer = { workspace = true }
@@ -29,13 +27,11 @@ vortex-decimal-byte-parts = { workspace = true }
 vortex-error = { workspace = true }
 vortex-fastlanes = { workspace = true }
 vortex-fsst = { workspace = true }
-vortex-mask = { workspace = true }
 vortex-onpair = { workspace = true, optional = true }
 vortex-pco = { workspace = true, optional = true }
 vortex-runend = { workspace = true }
 vortex-sequence = { workspace = true }
 vortex-sparse = { workspace = true }
-vortex-tensor = { workspace = true, optional = true }
 vortex-utils = { workspace = true }
 vortex-zigzag = { workspace = true }
 vortex-zstd = { workspace = true, optional = true }
@@ -49,11 +45,7 @@ vortex-session = { workspace = true }
 
 [features]
 # This feature enabled unstable encodings for which we don't guarantee stability.
-unstable_encodings = [
-    "dep:vortex-tensor",
-    "dep:vortex-onpair",
-    "vortex-zstd?/unstable_encodings",
-]
+unstable_encodings = ["dep:vortex-onpair", "vortex-zstd?/unstable_encodings"]
 pco = ["dep:pco", "dep:vortex-pco"]
 zstd = ["dep:vortex-zstd"]
 
diff --git a/vortex-btrblocks/src/builder.rs b/vortex-btrblocks/src/builder.rs
index 61c40341dbc..43df788473a 100644
--- a/vortex-btrblocks/src/builder.rs
+++ b/vortex-btrblocks/src/builder.rs
@@ -135,7 +135,7 @@ impl BtrBlocksCompressorBuilder {
         self
     }
 
-    /// Adds compact encoding schemes (Zstd for strings, Pco for numerics).
+    /// Adds compact encoding schemes (Zstd for strings and binary, Pco for numerics).
     ///
     /// This provides better compression ratios than the default, especially for floating-point
     /// heavy datasets. Requires the `zstd` feature. When the `pco` feature is also enabled,
@@ -146,7 +146,9 @@ impl BtrBlocksCompressorBuilder {
     /// Panics if any of the compact schemes are already present.
     #[cfg(feature = "zstd")]
     pub fn with_compact(self) -> Self {
-        let builder = self.with_new_scheme(&string::ZstdScheme);
+        let builder = self
+            .with_new_scheme(&string::ZstdScheme)
+            .with_new_scheme(&binary::ZstdScheme);
 
         #[cfg(feature = "pco")]
         let builder = builder
@@ -156,23 +158,7 @@ impl BtrBlocksCompressorBuilder {
         builder
     }
 
-    /// Adds the TurboQuant lossy vector quantization scheme.
-    ///
-    /// When enabled, [`Vector`] extension arrays are compressed using the TurboQuant algorithm
-    /// with MSE-optimal scalar quantization.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the TurboQuant scheme is already present.
-    ///
-    /// [`Vector`]: vortex_tensor::vector::Vector
-    #[cfg(feature = "unstable_encodings")]
-    pub fn with_turboquant(self) -> Self {
-        use vortex_tensor::encodings::turboquant::TurboQuantScheme;
-        self.with_new_scheme(&TurboQuantScheme)
-    }
-
-    /// Excludes schemes without CUDA kernel support and adds Zstd for string compression.
+    /// Excludes schemes without CUDA kernel support and adds Zstd for string and binary compression.
     ///
     /// With the `unstable_encodings` feature, buffer-level Zstd compression is used which
     /// preserves the array buffer layout for zero-conversion GPU decompression. Without it,
@@ -197,9 +183,13 @@ impl BtrBlocksCompressorBuilder {
         let builder = self.exclude_schemes(excluded);
 
         #[cfg(all(feature = "zstd", feature = "unstable_encodings"))]
-        let builder = builder.with_new_scheme(&string::ZstdBuffersScheme);
+        let builder = builder
+            .with_new_scheme(&string::ZstdBuffersScheme)
+            .with_new_scheme(&binary::ZstdBuffersScheme);
         #[cfg(all(feature = "zstd", not(feature = "unstable_encodings")))]
-        let builder = builder.with_new_scheme(&string::ZstdScheme);
+        let builder = builder
+            .with_new_scheme(&string::ZstdScheme)
+            .with_new_scheme(&binary::ZstdScheme);
 
         builder
     }
diff --git a/vortex-btrblocks/src/canonical_compressor.rs b/vortex-btrblocks/src/canonical_compressor.rs
index 175610d89a4..752b01d2f6e 100644
--- a/vortex-btrblocks/src/canonical_compressor.rs
+++ b/vortex-btrblocks/src/canonical_compressor.rs
@@ -91,6 +91,8 @@ mod tests {
     use vortex_session::VortexSession;
 
     use crate::BtrBlocksCompressor;
+    #[cfg(feature = "zstd")]
+    use crate::BtrBlocksCompressorBuilder;
 
     static SESSION: LazyLock<VortexSession> =
         LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
@@ -234,4 +236,68 @@ mod tests {
         assert_arrays_eq!(compressed, array);
         Ok(())
     }
+
+    #[cfg(feature = "zstd")]
+    #[test]
+    fn test_compact_binary_zstd_compressed() -> VortexResult<()> {
+        let values = (0..1024)
+            .map(|idx| {
+                let mut value = Vec::from(&b"common binary payload prefix "[..]);
+                value.extend_from_slice(&(idx as u32).to_le_bytes());
+                value.extend_from_slice(&[b'x'; 96]);
+                value
+            })
+            .collect::<Vec<_>>();
+        let array = VarBinViewArray::from_iter(
+            values.iter().map(|value| Some(value.as_slice())),
+            DType::Binary(Nullability::NonNullable),
+        );
+
+        let compressor = BtrBlocksCompressorBuilder::default().with_compact().build();
+        let compressed = compressor.compress(
+            &array.clone().into_array(),
+            &mut SESSION.create_execution_ctx(),
+        )?;
+
+        assert!(
+            compressed.is::<vortex_zstd::Zstd>(),
+            "expected Zstd, got {}",
+            compressed.encoding_id()
+        );
+        assert_arrays_eq!(compressed, array);
+        Ok(())
+    }
+
+    #[cfg(all(feature = "zstd", feature = "unstable_encodings"))]
+    #[test]
+    fn test_cuda_compatible_binary_zstd_buffers_compressed() -> VortexResult<()> {
+        let values = (0..1024)
+            .map(|idx| {
+                let mut value = Vec::from(&b"common binary payload prefix "[..]);
+                value.extend_from_slice(&(idx as u32).to_le_bytes());
+                value.extend_from_slice(&[b'x'; 96]);
+                value
+            })
+            .collect::<Vec<_>>();
+        let array = VarBinViewArray::from_iter(
+            values.iter().map(|value| Some(value.as_slice())),
+            DType::Binary(Nullability::NonNullable),
+        );
+
+        let compressor = BtrBlocksCompressorBuilder::default()
+            .only_cuda_compatible()
+            .build();
+        let compressed = compressor.compress(
+            &array.clone().into_array(),
+            &mut SESSION.create_execution_ctx(),
+        )?;
+
+        assert!(
+            compressed.is::<vortex_zstd::ZstdBuffers>(),
+            "expected ZstdBuffers, got {}",
+            compressed.encoding_id()
+        );
+        assert_arrays_eq!(compressed, array);
+        Ok(())
+    }
 }
diff --git a/vortex-btrblocks/src/schemes/binary.rs b/vortex-btrblocks/src/schemes/binary/mod.rs
similarity index 52%
rename from vortex-btrblocks/src/schemes/binary.rs
rename to vortex-btrblocks/src/schemes/binary/mod.rs
index 2e8b28cd396..44f09f2daa3 100644
--- a/vortex-btrblocks/src/schemes/binary.rs
+++ b/vortex-btrblocks/src/schemes/binary/mod.rs
@@ -3,6 +3,15 @@
 
 //! Binary compression schemes.
 
+#[cfg(feature = "zstd")]
+mod zstd;
+#[cfg(all(feature = "zstd", feature = "unstable_encodings"))]
+mod zstd_buffers;
+
 // Re-export builtin schemes from vortex-compressor.
 pub use vortex_compressor::builtins::BinaryConstantScheme;
 pub use vortex_compressor::builtins::BinaryDictScheme;
+#[cfg(feature = "zstd")]
+pub use zstd::ZstdScheme;
+#[cfg(all(feature = "zstd", feature = "unstable_encodings"))]
+pub use zstd_buffers::ZstdBuffersScheme;
diff --git a/vortex-btrblocks/src/schemes/binary/zstd.rs b/vortex-btrblocks/src/schemes/binary/zstd.rs
new file mode 100644
index 00000000000..56be76cdcb8
--- /dev/null
+++ b/vortex-btrblocks/src/schemes/binary/zstd.rs
@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Zstd compression for binary arrays.
+
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
+use vortex_compressor::estimate::CompressionEstimate;
+use vortex_compressor::estimate::DeferredEstimate;
+use vortex_error::VortexResult;
+
+use crate::ArrayAndStats;
+use crate::CascadingCompressor;
+use crate::CompressorContext;
+use crate::Scheme;
+
+/// Zstd compression without dictionaries for binary arrays.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct ZstdScheme;
+
+impl Scheme for ZstdScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.binary.zstd"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        canonical.dtype().is_binary()
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        _data: &ArrayAndStats,
+        _compress_ctx: CompressorContext,
+        _exec_ctx: &mut ExecutionCtx,
+    ) -> CompressionEstimate {
+        CompressionEstimate::Deferred(DeferredEstimate::Sample)
+    }
+
+    fn compress(
+        &self,
+        _compressor: &CascadingCompressor,
+        data: &ArrayAndStats,
+        _compress_ctx: CompressorContext,
+        exec_ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let compacted = data.array_as_varbinview().into_owned().compact_buffers()?;
+        Ok(
+            vortex_zstd::Zstd::from_var_bin_view_without_dict(&compacted, 3, 8192, exec_ctx)?
+                .into_array(),
+        )
+    }
+}
diff --git a/vortex-btrblocks/src/schemes/binary/zstd_buffers.rs b/vortex-btrblocks/src/schemes/binary/zstd_buffers.rs
new file mode 100644
index 00000000000..269665866a2
--- /dev/null
+++ b/vortex-btrblocks/src/schemes/binary/zstd_buffers.rs
@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Zstd buffer-level binary compression preserving array layout for GPU decompression.
+
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
+use vortex_compressor::estimate::CompressionEstimate;
+use vortex_compressor::estimate::DeferredEstimate;
+use vortex_error::VortexResult;
+
+use crate::ArrayAndStats;
+use crate::CascadingCompressor;
+use crate::CompressorContext;
+use crate::Scheme;
+
+/// Zstd buffer-level compression preserving array layout for GPU decompression.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct ZstdBuffersScheme;
+
+impl Scheme for ZstdBuffersScheme {
+    fn scheme_name(&self) -> &'static str {
+        "vortex.binary.zstd_buffers"
+    }
+
+    fn matches(&self, canonical: &Canonical) -> bool {
+        canonical.dtype().is_binary()
+    }
+
+    fn expected_compression_ratio(
+        &self,
+        _data: &ArrayAndStats,
+        _compress_ctx: CompressorContext,
+        _exec_ctx: &mut ExecutionCtx,
+    ) -> CompressionEstimate {
+        CompressionEstimate::Deferred(DeferredEstimate::Sample)
+    }
+
+    fn compress(
+        &self,
+        _compressor: &CascadingCompressor,
+        data: &ArrayAndStats,
+        _compress_ctx: CompressorContext,
+        exec_ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        Ok(vortex_zstd::ZstdBuffers::compress(data.array(), 3, exec_ctx.session())?.into_array())
+    }
+}
diff --git a/vortex-buffer/benches/vortex_bitbuffer.rs b/vortex-buffer/benches/vortex_bitbuffer.rs
index 67ce88da889..7efc6c6a114 100644
--- a/vortex-buffer/benches/vortex_bitbuffer.rs
+++ b/vortex-buffer/benches/vortex_bitbuffer.rs
@@ -210,6 +210,17 @@ fn bitwise_and_arrow_buffer(bencher: Bencher, length: usize) {
         .bench_refs(|(a, b)| &a.0 & &b.0);
 }
 
+/// Owned-LHS AND: the left operand is a fresh, uniquely-owned `BitBuffer` each iteration, so
+/// `bitwise_binary_op_lhs_owned` takes the in-place (zero-allocation) fast path. Compare against
+/// `bitwise_and_vortex_buffer` (reference-LHS, which always allocates a result buffer).
+#[divan::bench(args = INPUT_SIZE)]
+fn bitand_owned_lhs_vortex_buffer(bencher: Bencher, length: usize) {
+    let b = BitBuffer::from_iter((0..length).map(|i| i % 3 == 0));
+    bencher
+        .with_inputs(|| BitBuffer::from_iter((0..length).map(|i| i % 2 == 0)))
+        .bench_values(|a| a & &b);
+}
+
 #[divan::bench(args = INPUT_SIZE)]
 fn bitwise_or_vortex_buffer(bencher: Bencher, length: usize) {
     let a = BitBuffer::from_iter((0..length).map(|i| i % 2 == 0));
diff --git a/vortex-buffer/benches/vortex_buffer.rs b/vortex-buffer/benches/vortex_buffer.rs
index 5c97cbb3915..74a402887f0 100644
--- a/vortex-buffer/benches/vortex_buffer.rs
+++ b/vortex-buffer/benches/vortex_buffer.rs
@@ -140,6 +140,42 @@ fn push_n_vortex_buffer<T: PrimInt>(bencher: Bencher, length: usize) {
         });
 }
 
+const SLICE_WINDOW: usize = 64;
+
+#[divan::bench(args = &[65_536usize])]
+fn slice_tight_loop_vortex(bencher: Bencher, len: usize) {
+    let buf = Buffer::<i32>::from_iter(
+        (0..i32::try_from(len).vortex_expect("len fits into i32")).map(|i| i % i32::MAX),
+    );
+    bencher.bench(|| {
+        let mut offset = 0;
+        while offset + SLICE_WINDOW <= len {
+            divan::black_box(buf.slice(offset..offset + SLICE_WINDOW));
+            offset += SLICE_WINDOW;
+        }
+    });
+}
+
+#[divan::bench(args = &[65_536usize])]
+fn slice_tight_loop_arrow(bencher: Bencher, len: usize) {
+    let buf = ScalarBuffer::<i32>::from_iter(
+        (0..i32::try_from(len).vortex_expect("len fits into i32")).map(|i| i % i32::MAX),
+    );
+    bencher.bench(|| {
+        let mut offset = 0;
+        while offset + SLICE_WINDOW <= len {
+            divan::black_box(buf.slice(offset, SLICE_WINDOW));
+            offset += SLICE_WINDOW;
+        }
+    });
+}
+
+#[divan::bench]
+fn slice_empty_vortex(bencher: Bencher) {
+    let buf = Buffer::<i32>::from_iter((0..1024).map(|i| i % i32::MAX));
+    bencher.bench(|| divan::black_box(buf.slice(8..8)));
+}
+
 #[divan::bench(args = INPUT_SIZE)]
 fn map_new_output(bencher: Bencher, n: i32) {
     bencher
diff --git a/vortex-buffer/src/bit/buf.rs b/vortex-buffer/src/bit/buf.rs
index 83b28e24b4a..457827f4ab9 100644
--- a/vortex-buffer/src/bit/buf.rs
+++ b/vortex-buffer/src/bit/buf.rs
@@ -25,7 +25,9 @@ use crate::bit::collect_bool_word;
 use crate::bit::count_ones::count_ones;
 use crate::bit::get_bit_unchecked;
 use crate::bit::ops::bitwise_binary_op;
+use crate::bit::ops::bitwise_binary_op_lhs_owned;
 use crate::bit::ops::bitwise_unary_op;
+use crate::bit::ops::bitwise_unary_op_copy;
 use crate::bit::select::bit_select;
 use crate::buffer;
 
@@ -59,6 +61,29 @@ impl PartialEq for BitBuffer {
             return false;
         }
 
+        if self.len == 0 {
+            return true;
+        }
+
+        // Fast path: both byte-aligned and same length — direct byte comparison.
+        if self.offset == 0 && other.offset == 0 {
+            let full_bytes = self.len / 8;
+            let self_bytes = &self.buffer.as_slice()[..full_bytes];
+            let other_bytes = &other.buffer.as_slice()[..full_bytes];
+            if self_bytes != other_bytes {
+                return false;
+            }
+            // Compare remaining bits in the last partial byte.
+            let rem = self.len % 8;
+            if rem != 0 {
+                let mask = (1u8 << rem) - 1;
+                let a = self.buffer.as_slice()[full_bytes] & mask;
+                let b = other.buffer.as_slice()[full_bytes] & mask;
+                return a == b;
+            }
+            return true;
+        }
+
         self.chunks()
             .iter_padded()
             .zip(other.chunks().iter_padded())
@@ -315,6 +340,7 @@ impl BitBuffer {
     }
 
     /// Get the number of set bits in the buffer.
+    #[inline]
     pub fn true_count(&self) -> usize {
         count_ones(self.buffer.as_slice(), self.offset, self.len)
     }
@@ -330,6 +356,7 @@ impl BitBuffer {
     }
 
     /// Get the number of unset bits in the buffer.
+    #[inline]
     pub fn false_count(&self) -> usize {
         self.len - self.true_count()
     }
@@ -353,12 +380,14 @@ impl BitBuffer {
     pub fn sliced(&self) -> Self {
         if self.offset.is_multiple_of(8) {
             return Self::new(
-                self.buffer.slice(self.offset / 8..self.len.div_ceil(8)),
+                self.buffer
+                    .slice(self.offset / 8..(self.offset + self.len).div_ceil(8)),
                 self.len,
             );
         }
 
-        bitwise_unary_op(self.clone(), |a| a)
+        // Allocate directly rather than clone + identity op which would fail try_into_mut.
+        bitwise_unary_op_copy(self, |a| a)
     }
 }
 
@@ -402,7 +431,7 @@ impl BitOr for BitBuffer {
 
     #[inline]
     fn bitor(self, rhs: Self) -> Self::Output {
-        BitOr::bitor(&self, &rhs)
+        bitwise_binary_op_lhs_owned(self, &rhs, |a, b| a | b)
     }
 }
 
@@ -420,7 +449,7 @@ impl BitOr<&BitBuffer> for BitBuffer {
 
     #[inline]
     fn bitor(self, rhs: &BitBuffer) -> Self::Output {
-        (&self).bitor(rhs)
+        bitwise_binary_op_lhs_owned(self, rhs, |a, b| a | b)
     }
 }
 
@@ -447,7 +476,7 @@ impl BitAnd<&BitBuffer> for BitBuffer {
 
     #[inline]
     fn bitand(self, rhs: &BitBuffer) -> Self::Output {
-        (&self).bitand(rhs)
+        bitwise_binary_op_lhs_owned(self, rhs, |a, b| a & b)
     }
 }
 
@@ -456,7 +485,7 @@ impl BitAnd<BitBuffer> for BitBuffer {
 
     #[inline]
     fn bitand(self, rhs: BitBuffer) -> Self::Output {
-        (&self).bitand(&rhs)
+        bitwise_binary_op_lhs_owned(self, &rhs, |a, b| a & b)
     }
 }
 
@@ -465,7 +494,9 @@ impl Not for &BitBuffer {
 
     #[inline]
     fn not(self) -> Self::Output {
-        !self.clone()
+        // Allocate directly rather than clone+try_into_mut, which always fails
+        // since the clone shares the Arc with the original reference.
+        bitwise_unary_op_copy(self, |a| !a)
     }
 }
 
@@ -492,7 +523,7 @@ impl BitXor<&BitBuffer> for BitBuffer {
 
     #[inline]
     fn bitxor(self, rhs: &BitBuffer) -> Self::Output {
-        (&self).bitxor(rhs)
+        bitwise_binary_op_lhs_owned(self, rhs, |a, b| a ^ b)
     }
 }
 
@@ -505,6 +536,11 @@ impl BitBuffer {
         bitwise_binary_op(self, rhs, |a, b| a & !b)
     }
 
+    /// Owned variant of [`bitand_not`](Self::bitand_not) that can mutate in-place when possible.
+    pub fn into_bitand_not(self, rhs: &BitBuffer) -> BitBuffer {
+        bitwise_binary_op_lhs_owned(self, rhs, |a, b| a & !b)
+    }
+
     /// Iterate through bits in a buffer.
     ///
     /// # Arguments
@@ -524,44 +560,23 @@ impl BitBuffer {
             return;
         }
 
-        let is_bit_set = |byte: u8, bit_idx: usize| (byte & (1 << bit_idx)) != 0;
-        let bit_offset = self.offset % 8;
-        let mut buffer_ptr = unsafe { self.buffer.as_ptr().add(self.offset / 8) };
-        let mut callback_idx = 0;
-
-        // Handle incomplete first byte.
-        if bit_offset > 0 {
-            let bits_in_first_byte = (8 - bit_offset).min(total_bits);
-            let byte = unsafe { *buffer_ptr };
-
-            for bit_idx in 0..bits_in_first_byte {
-                f(callback_idx, is_bit_set(byte, bit_offset + bit_idx));
-                callback_idx += 1;
-            }
-
-            buffer_ptr = unsafe { buffer_ptr.add(1) };
-        }
-
-        // Process complete bytes.
-        let complete_bytes = (total_bits - callback_idx) / 8;
-        for _ in 0..complete_bytes {
-            let byte = unsafe { *buffer_ptr };
+        // Process in 64-bit chunks for better ILP and fewer loop iterations.
+        let chunks = self.chunks();
+        let chunks_count = total_bits / 64;
+        let remainder = total_bits % 64;
 
-            for bit_idx in 0..8 {
-                f(callback_idx, is_bit_set(byte, bit_idx));
-                callback_idx += 1;
+        for (chunk_idx, chunk) in chunks.iter().enumerate() {
+            let base = chunk_idx * 64;
+            for bit_idx in 0..64 {
+                f(base + bit_idx, (chunk >> bit_idx) & 1 == 1);
             }
-            buffer_ptr = unsafe { buffer_ptr.add(1) };
         }
 
-        // Handle remaining bits at the end.
-        let remaining_bits = total_bits - callback_idx;
-        if remaining_bits > 0 {
-            let byte = unsafe { *buffer_ptr };
-
-            for bit_idx in 0..remaining_bits {
-                f(callback_idx, is_bit_set(byte, bit_idx));
-                callback_idx += 1;
+        if remainder != 0 {
+            let rem_chunk = chunks.remainder_bits();
+            let base = chunks_count * 64;
+            for bit_idx in 0..remainder {
+                f(base + bit_idx, (rem_chunk >> bit_idx) & 1 == 1);
             }
         }
     }
diff --git a/vortex-buffer/src/bit/buf_mut.rs b/vortex-buffer/src/bit/buf_mut.rs
index a366eaae9a8..02e4ce66755 100644
--- a/vortex-buffer/src/bit/buf_mut.rs
+++ b/vortex-buffer/src/bit/buf_mut.rs
@@ -17,7 +17,7 @@ use crate::buffer_mut;
 
 /// Sets all bits in the bit-range `[start_bit, end_bit)` of `slice` to `value`.
 #[inline(always)]
-fn fill_bits(slice: &mut [u8], start_bit: usize, end_bit: usize, value: bool) {
+pub(crate) fn fill_bits(slice: &mut [u8], start_bit: usize, end_bit: usize, value: bool) {
     if start_bit >= end_bit {
         return;
     }
@@ -275,6 +275,7 @@ impl BitBufferMut {
     /// Set the bit at `index` to the given boolean value.
     ///
     /// This operation is checked so if `index` exceeds the buffer length, this will panic.
+    #[inline]
     pub fn set_to(&mut self, index: usize, value: bool) {
         if value {
             self.set(index);
@@ -288,6 +289,7 @@ impl BitBufferMut {
     /// # Safety
     ///
     /// The caller must ensure that `index` does not exceed the largest bit index in the backing buffer.
+    #[inline]
     pub unsafe fn set_to_unchecked(&mut self, index: usize, value: bool) {
         if value {
             // SAFETY: checked by caller
@@ -301,6 +303,7 @@ impl BitBufferMut {
     /// Set a position to `true`.
     ///
     /// This operation is checked so if `index` exceeds the buffer length, this will panic.
+    #[inline]
     pub fn set(&mut self, index: usize) {
         assert!(index < self.len, "index {index} exceeds len {}", self.len);
 
@@ -373,12 +376,21 @@ impl BitBufferMut {
             return;
         }
 
-        let new_len_bytes = (self.offset + len).div_ceil(8);
+        let end_bit = self.offset + len;
+        let new_len_bytes = end_bit.div_ceil(8);
         self.buffer.truncate(new_len_bytes);
         self.len = len;
+
+        // Clear stale bits in the final partial byte so the "bits beyond len are zero" invariant
+        // holds. `append_false` (and `append_buffer`) rely on it to avoid a read-modify-write.
+        if !end_bit.is_multiple_of(8) {
+            let keep = (1u8 << (end_bit % 8)) - 1;
+            self.buffer.as_mut_slice()[new_len_bytes - 1] &= keep;
+        }
     }
 
     /// Append a new boolean into the bit buffer, incrementing the length.
+    #[inline]
     pub fn append(&mut self, value: bool) {
         if value {
             self.append_true()
@@ -388,6 +400,7 @@ impl BitBufferMut {
     }
 
     /// Append a new true value to the buffer.
+    #[inline]
     pub fn append_true(&mut self) {
         let bit_pos = self.offset + self.len;
         let byte_pos = bit_pos / 8;
@@ -404,21 +417,18 @@ impl BitBufferMut {
     }
 
     /// Append a new false value to the buffer.
+    #[inline]
     pub fn append_false(&mut self) {
         let bit_pos = self.offset + self.len;
         let byte_pos = bit_pos / 8;
-        let bit_in_byte = bit_pos % 8;
 
-        // Ensure buffer has enough bytes
+        // Ensure buffer has enough bytes (pushed as 0x00, so bit is already unset).
         if byte_pos >= self.buffer.len() {
             self.buffer.push(0u8);
         }
 
-        // Bit is already 0 if we just pushed a new byte, otherwise ensure it's unset
-        if bit_in_byte != 0 {
-            self.buffer.as_mut_slice()[byte_pos] &= !(1 << bit_in_byte);
-        }
-
+        // The bit is guaranteed to be 0: new bytes are zero-initialized, and
+        // existing bytes have this bit unset (it's beyond the current length).
         self.len += 1;
     }
 
@@ -487,24 +497,39 @@ impl BitBufferMut {
         let end_bit_pos = start_bit_pos + bit_len;
         let required_bytes = end_bit_pos.div_ceil(8);
 
-        // Ensure buffer has enough bytes
+        // Ensure buffer has enough bytes, zero-initialized for OR-based writes.
         if required_bytes > self.buffer.len() {
             self.buffer.push_n(0x00, required_bytes - self.buffer.len());
         }
 
-        // Use bitvec for efficient bit copying
-        let self_slice = self
-            .buffer
-            .as_mut_slice()
-            .view_bits_mut::<bitvec::prelude::Lsb0>();
-        let other_slice = buffer
-            .inner()
-            .as_slice()
-            .view_bits::<bitvec::prelude::Lsb0>();
-
-        // Copy from source buffer (accounting for its offset) to destination (accounting for our offset + len)
-        let source_range = buffer.offset()..buffer.offset() + bit_len;
-        self_slice[start_bit_pos..end_bit_pos].copy_from_bitslice(&other_slice[source_range]);
+        let dst_bit_offset = start_bit_pos % 8;
+        let src_bit_offset = buffer.offset();
+
+        if dst_bit_offset == 0 && src_bit_offset == 0 {
+            // Both byte-aligned: use memcpy for full bytes, then mask the tail.
+            let dst_byte = start_bit_pos / 8;
+            let src_bytes = buffer.inner().as_slice();
+            let full_bytes = bit_len / 8;
+            self.buffer.as_mut_slice()[dst_byte..dst_byte + full_bytes]
+                .copy_from_slice(&src_bytes[..full_bytes]);
+            let rem = bit_len % 8;
+            if rem != 0 {
+                let mask = (1u8 << rem) - 1;
+                self.buffer.as_mut_slice()[dst_byte + full_bytes] |= src_bytes[full_bytes] & mask;
+            }
+        } else {
+            // Use bitvec for unaligned bit copying.
+            let self_slice = self
+                .buffer
+                .as_mut_slice()
+                .view_bits_mut::<bitvec::prelude::Lsb0>();
+            let other_slice = buffer
+                .inner()
+                .as_slice()
+                .view_bits::<bitvec::prelude::Lsb0>();
+            let source_range = src_bit_offset..src_bit_offset + bit_len;
+            self_slice[start_bit_pos..end_bit_pos].copy_from_bitslice(&other_slice[source_range]);
+        }
 
         self.len += bit_len;
     }
@@ -581,6 +606,7 @@ impl From<Vec<bool>> for BitBufferMut {
 }
 
 impl FromIterator<bool> for BitBufferMut {
+    #[inline]
     fn from_iter<T: IntoIterator<Item = bool>>(iter: T) -> Self {
         let mut iter = iter.into_iter();
 
@@ -611,7 +637,8 @@ impl FromIterator<bool> for BitBufferMut {
             }
         }
 
-        // Append the remaining items (as we do not know how many more there are).
+        // Append any remaining items one at a time, as we do not know how many more there are.
+        // (`append` is already a single branch + bit set, see `append_true`/`append_false`.)
         for v in iter {
             buf.append(v);
         }
@@ -659,6 +686,24 @@ mod tests {
         assert!(bools.value(9));
     }
 
+    #[test]
+    fn append_false_after_truncate_reads_back_false() {
+        // `truncate` leaves stale bits in the final partial byte; a subsequent `append_false`
+        // must still read back as false. Regression test for the `append_false` fast path.
+        let mut bools = BitBufferMut::new_set(16);
+        bools.truncate(12);
+        bools.append_false();
+        bools.append_true();
+
+        let bools = bools.freeze();
+        assert_eq!(bools.len(), 14);
+        assert!(
+            !bools.value(12),
+            "appended false must read back false after truncate"
+        );
+        assert!(bools.value(13));
+    }
+
     #[test]
     fn test_reserve_ensures_len_plus_additional() {
         // This test documents the fix for the bug where reserve was incorrectly
diff --git a/vortex-buffer/src/bit/meta.rs b/vortex-buffer/src/bit/meta.rs
new file mode 100644
index 00000000000..866a308647d
--- /dev/null
+++ b/vortex-buffer/src/bit/meta.rs
@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+/// In-memory metadata describing a packed bitset: a normalized bit `offset` (always `< 8`) and a
+/// logical bit `len`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct BitBufferMeta {
+    offset: usize,
+    len: usize,
+}
+
+impl BitBufferMeta {
+    /// Create metadata for a bitset starting at bit `offset` with `len` bits.
+    ///
+    /// Panics if `offset >= 8`. Use [`from_raw_offset`](Self::from_raw_offset) to normalize a
+    /// larger offset.
+    pub fn new(offset: usize, len: usize) -> Self {
+        assert!(offset < 8, "BitBufferMeta offset must be < 8, got {offset}");
+        Self { offset, len }
+    }
+
+    /// Normalize a raw bit `offset` into a whole-byte offset plus metadata whose `offset` is
+    /// `< 8`.
+    ///
+    /// Returns `(byte_offset, meta)` so the caller can slice its backing buffer by `byte_offset`
+    /// and store the remaining sub-byte offset in `meta`.
+    pub fn from_raw_offset(offset: usize, len: usize) -> (usize, Self) {
+        (
+            offset / 8,
+            Self {
+                offset: offset % 8,
+                len,
+            },
+        )
+    }
+
+    /// The sub-byte bit offset. Always `< 8`.
+    #[inline(always)]
+    pub fn offset(&self) -> usize {
+        self.offset
+    }
+
+    /// The logical length of the bitset in bits.
+    #[inline(always)]
+    pub fn len(&self) -> usize {
+        self.len
+    }
+
+    /// Returns `true` if the bitset is empty.
+    #[inline(always)]
+    pub fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
+    /// The number of backing bytes required to hold `offset + len` bits.
+    #[inline]
+    pub fn byte_len(&self) -> usize {
+        (self.offset + self.len).div_ceil(8)
+    }
+}
diff --git a/vortex-buffer/src/bit/mod.rs b/vortex-buffer/src/bit/mod.rs
index a4fe1345e60..41bb5797266 100644
--- a/vortex-buffer/src/bit/mod.rs
+++ b/vortex-buffer/src/bit/mod.rs
@@ -12,8 +12,10 @@ mod buf;
 mod buf_mut;
 mod count_ones;
 mod macros;
+mod meta;
 mod ops;
 mod select;
+mod view;
 
 pub use arrow_buffer::bit_chunk_iterator::BitChunkIterator;
 pub use arrow_buffer::bit_chunk_iterator::BitChunks;
@@ -24,6 +26,8 @@ pub use arrow_buffer::bit_iterator::BitIterator;
 pub use arrow_buffer::bit_iterator::BitSliceIterator;
 pub use buf::*;
 pub use buf_mut::*;
+pub use meta::*;
+pub use view::*;
 
 /// Packs up to 64 boolean values into a little-endian `u64` word.
 #[inline]
diff --git a/vortex-buffer/src/bit/ops.rs b/vortex-buffer/src/bit/ops.rs
index 9406c728f06..be1401d912a 100644
--- a/vortex-buffer/src/bit/ops.rs
+++ b/vortex-buffer/src/bit/ops.rs
@@ -1,89 +1,184 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::mem::MaybeUninit;
+
 use crate::BitBuffer;
 use crate::BitBufferMut;
 use crate::Buffer;
 use crate::ByteBufferMut;
 use crate::trusted_len::TrustedLenExt;
 
+/// Read up to 8 bytes as a little-endian `u64`, zero-padding the high bytes when fewer than 8 are
+/// supplied. Using [`u64::from_le_bytes`] keeps the bit-numbering identical on little- and
+/// big-endian targets; for a full 8-byte slice it lowers to a single word load.
 #[inline]
-pub(super) fn bitwise_unary_op<F: FnMut(u64) -> u64>(buffer: BitBuffer, mut op: F) -> BitBuffer {
-    match buffer.try_into_mut() {
-        Ok(mut buf) => {
-            bitwise_unary_op_mut(&mut buf, op);
-            buf.freeze()
-        }
-        Err(buffer) => {
-            let len = buffer.len();
-            let offset = buffer.offset();
-            let src = buffer.inner().as_slice();
-
-            let mut dst = ByteBufferMut::with_capacity(src.len());
-            let u64_len = src.len() / 8;
-            let remainder = src.len() % 8;
-
-            let mut src_ptr = src.as_ptr() as *const u64;
-            let mut dst_ptr = dst.spare_capacity_mut().as_mut_ptr() as *mut u64;
-            for _ in 0..u64_len {
-                let value = unsafe { src_ptr.read_unaligned() };
-                unsafe { dst_ptr.write_unaligned(op(value)) };
-                src_ptr = unsafe { src_ptr.add(1) };
-                dst_ptr = unsafe { dst_ptr.add(1) };
-            }
+fn read_u64_le(bytes: &[u8]) -> u64 {
+    debug_assert!(bytes.len() <= 8);
+    let mut buf = [0u8; 8];
+    buf[..bytes.len()].copy_from_slice(bytes);
+    u64::from_le_bytes(buf)
+}
 
-            if remainder > 0 {
-                let mut remainder_u64 = 0u64;
-                let src_bytes = src_ptr as *const u8;
-                let dst_bytes = dst_ptr as *mut u8;
-                for i in 0..remainder {
-                    let byte = unsafe { src_bytes.add(i).read() };
-                    remainder_u64 |= (byte as u64) << (i * 8);
-                }
-                let remainder_u64 = op(remainder_u64);
-                for i in 0..remainder {
-                    let byte = ((remainder_u64 >> (i * 8)) & 0xFF) as u8;
-                    unsafe { dst_bytes.add(i).write(byte) };
-                }
-            }
+trait BitWordTarget {
+    fn byte_len(&self) -> usize;
 
-            // SAFETY: we wrote exactly src.len() bytes into the spare capacity.
-            unsafe { dst.set_len(src.len()) };
-            BitBuffer::new_with_offset(dst.freeze(), len, offset)
+    fn read_word(&self, byte_offset: usize, len: usize) -> u64;
+
+    fn write_word(&mut self, byte_offset: usize, word: &[u8]);
+}
+
+impl BitWordTarget for &mut [u8] {
+    #[inline]
+    fn byte_len(&self) -> usize {
+        (**self).len()
+    }
+
+    #[inline]
+    fn read_word(&self, byte_offset: usize, len: usize) -> u64 {
+        read_u64_le(&(**self)[byte_offset..byte_offset + len])
+    }
+
+    #[inline]
+    fn write_word(&mut self, byte_offset: usize, word: &[u8]) {
+        (**self)[byte_offset..byte_offset + word.len()].copy_from_slice(word);
+    }
+}
+
+struct OutOfPlaceBitWordTarget<'a> {
+    src: &'a [u8],
+    dst: &'a mut [MaybeUninit<u8>],
+}
+
+impl<'a> OutOfPlaceBitWordTarget<'a> {
+    #[inline]
+    fn new(src: &'a [u8], dst: &'a mut [MaybeUninit<u8>]) -> Self {
+        debug_assert!(dst.len() >= src.len());
+        Self { src, dst }
+    }
+}
+
+impl BitWordTarget for OutOfPlaceBitWordTarget<'_> {
+    #[inline]
+    fn byte_len(&self) -> usize {
+        self.src.len()
+    }
+
+    #[inline]
+    fn read_word(&self, byte_offset: usize, len: usize) -> u64 {
+        read_u64_le(&self.src[byte_offset..byte_offset + len])
+    }
+
+    #[inline]
+    fn write_word(&mut self, byte_offset: usize, word: &[u8]) {
+        for (dst_byte, byte) in self.dst[byte_offset..byte_offset + word.len()]
+            .iter_mut()
+            .zip(word)
+        {
+            dst_byte.write(*byte);
         }
     }
 }
 
+/// Apply `op` to each little-endian `u64` word of `target`.
+///
+/// The target is split into full `u64` words, with the trailing `len % 8` bytes handled as
+/// one final partial word (see [`read_u64_le`]).
 #[inline]
-pub(super) fn bitwise_unary_op_mut<F: FnMut(u64) -> u64>(buffer: &mut BitBufferMut, mut op: F) {
-    let slice_mut = buffer.as_mut_slice();
+fn map_u64_words<T: BitWordTarget, F: FnMut(u64) -> u64>(mut target: T, mut op: F) {
+    let len = target.byte_len();
+    let full_bytes = len - (len % 8);
 
-    // The number of complete u64 words in the buffer (unaligned)
-    let u64_len = slice_mut.len() / 8;
-    let remainder = slice_mut.len() % 8;
+    for byte_offset in (0..full_bytes).step_by(8) {
+        let word = op(target.read_word(byte_offset, 8)).to_le_bytes();
+        target.write_word(byte_offset, &word);
+    }
 
-    // Create a pointer to the *unaligned* u64 words
-    let mut ptr = slice_mut.as_mut_ptr() as *mut u64;
-    for _ in 0..u64_len {
-        let value = unsafe { ptr.read_unaligned() };
-        let value = op(value);
-        unsafe { ptr.write_unaligned(value) };
-        ptr = unsafe { ptr.add(1) };
+    if full_bytes != len {
+        let tail_len = len - full_bytes;
+        let word = op(target.read_word(full_bytes, tail_len)).to_le_bytes();
+        target.write_word(full_bytes, &word[..tail_len]);
     }
+}
 
-    // Read remainder into a u64;
-    let mut remainder_u64 = 0u64;
-    let ptr = ptr as *mut u8;
-    for i in 0..remainder {
-        let byte = unsafe { ptr.add(i).read() };
-        remainder_u64 |= (byte as u64) << (i * 8);
+/// Combine each little-endian `u64` word of `dst` with the matching word of `src` via `op`,
+/// writing the result back into `dst`. Processes `dst.len().min(src.len())` bytes, with the
+/// trailing partial word handled like [`map_u64_words`].
+#[inline]
+fn zip_u64_words_in_place<F: FnMut(u64, u64) -> u64>(dst: &mut [u8], src: &[u8], mut op: F) {
+    let n = dst.len().min(src.len());
+    let (dst_words, dst_tail) = dst[..n].as_chunks_mut::<8>();
+    let (src_words, src_tail) = src[..n].as_chunks::<8>();
+    for (d, s) in dst_words.iter_mut().zip(src_words) {
+        *d = op(u64::from_le_bytes(*d), u64::from_le_bytes(*s)).to_le_bytes();
+    }
+    // Both slices were truncated to `n`, so their tails are the same length.
+    if !dst_tail.is_empty() {
+        let word = op(read_u64_le(dst_tail), read_u64_le(src_tail)).to_le_bytes();
+        dst_tail.copy_from_slice(&word[..dst_tail.len()]);
     }
-    let remainder_u64 = op(remainder_u64);
+}
 
-    // Write back remainder
-    for i in 0..remainder {
-        let byte = ((remainder_u64 >> (i * 8)) & 0xFF) as u8;
-        unsafe { ptr.add(i).write(byte) };
+/// Apply a unary operation to a [`BitBuffer`], always allocating a new output buffer.
+#[inline]
+pub(super) fn bitwise_unary_op_copy<F: FnMut(u64) -> u64>(buffer: &BitBuffer, op: F) -> BitBuffer {
+    let src = buffer.inner().as_slice();
+    let mut bytes = ByteBufferMut::with_capacity(src.len());
+    map_u64_words(
+        OutOfPlaceBitWordTarget::new(src, bytes.spare_capacity_mut()),
+        op,
+    );
+    // SAFETY: `map_u64_words` initializes every byte in `0..src.len()` for
+    // `OutOfPlaceU64WordTarget`.
+    unsafe { bytes.set_len(src.len()) };
+    BitBufferMut::from_buffer(bytes, buffer.offset(), buffer.len()).freeze()
+}
+
+/// Apply a unary operation to an owned [`BitBuffer`], mutating in-place when possible.
+///
+/// Tries to get exclusive access via `try_into_mut`. If the backing storage is shared
+/// (Arc refcount > 1), falls back to [`bitwise_unary_op_copy`].
+#[inline]
+pub(super) fn bitwise_unary_op<F: FnMut(u64) -> u64>(buffer: BitBuffer, op: F) -> BitBuffer {
+    match buffer.try_into_mut() {
+        Ok(mut buf) => {
+            bitwise_unary_op_mut(&mut buf, op);
+            buf.freeze()
+        }
+        Err(buffer) => bitwise_unary_op_copy(&buffer, op),
+    }
+}
+
+#[inline]
+pub(super) fn bitwise_unary_op_mut<F: FnMut(u64) -> u64>(buffer: &mut BitBufferMut, op: F) {
+    map_u64_words(buffer.as_mut_slice(), op);
+}
+
+/// Apply a binary operation with an owned left operand, mutating in-place when possible.
+///
+/// Tries `try_into_mut` on the left operand. If the backing storage has exclusive access,
+/// the operation is performed in-place (zero allocation). Otherwise, falls back to
+/// [`bitwise_binary_op`] which allocates a new buffer.
+pub(super) fn bitwise_binary_op_lhs_owned<F: FnMut(u64, u64) -> u64>(
+    left: BitBuffer,
+    right: &BitBuffer,
+    op: F,
+) -> BitBuffer {
+    assert_eq!(left.len(), right.len());
+
+    // The in-place path combines the operands word-for-word, which only lines up the logical bits
+    // when both share the same bit-to-byte alignment. When the offsets differ, fall back to the
+    // offset-aware allocating path (`bitwise_binary_op`) rather than corrupting the result.
+    if left.offset() != right.offset() {
+        return bitwise_binary_op(&left, right, op);
+    }
+
+    match left.try_into_mut() {
+        Ok(mut buf) => {
+            zip_u64_words_in_place(buf.as_mut_slice(), right.inner().as_slice(), op);
+            buf.freeze()
+        }
+        Err(left) => bitwise_binary_op(&left, right, op),
     }
 }
 
@@ -129,7 +224,10 @@ pub(super) fn bitwise_binary_op<F: FnMut(u64, u64) -> u64>(
 mod tests {
     use std::ops::Not;
 
+    use rstest::rstest;
+
     use super::*;
+    use crate::ByteBufferMut;
     use crate::bitbuffer;
     use crate::buffer;
 
@@ -140,6 +238,58 @@ mod tests {
         assert_eq!(result, bitbuffer![true, false, true, false]);
     }
 
+    #[test]
+    fn test_lhs_owned_offset_mismatch_regression() {
+        use crate::buffer_mut;
+
+        // `left` has bit offset 3 and uniquely-owned backing storage, so the in-place fast
+        // path is taken. Byte 0b1111_1000 → logical bits [3..8) = [1,1,1,1,1].
+        let left = BitBufferMut::from_buffer(buffer_mut![0b1111_1000u8], 3, 5).freeze();
+        // `right` has bit offset 0. Byte 0b0001_1111 → logical bits [0..5) = [1,1,1,1,1].
+        let right = BitBuffer::new(buffer![0b0001_1111u8], 5);
+
+        // AND of two all-true ranges must be all-true. The naive byte-wise in-place path
+        // ignores the differing offsets and yields the wrong answer.
+        let got = bitwise_binary_op_lhs_owned(left, &right, |a, b| a & b);
+        assert_eq!(got.true_count(), 5);
+        assert_eq!(got, bitbuffer![true, true, true, true, true]);
+    }
+
+    /// The owned-LHS path (in-place when uniquely owned and the offsets match) must produce the
+    /// same logical result as the always-correct allocating [`bitwise_binary_op`], for every
+    /// combination of operand offsets and lengths.
+    #[rstest]
+    #[case::aligned(0, 0)]
+    #[case::equal_nonzero(3, 3)]
+    #[case::equal_seven(7, 7)]
+    #[case::mismatch_lo(0, 3)]
+    #[case::mismatch_hi(5, 2)]
+    fn lhs_owned_matches_reference(#[case] left_offset: usize, #[case] right_offset: usize) {
+        // Deterministic byte pattern, so the owned and borrowed inputs are bit-identical.
+        #[allow(clippy::cast_possible_truncation)]
+        let make = |offset: usize, len: usize, salt: u8| -> BitBuffer {
+            let bytes: ByteBufferMut = (0..(offset + len).div_ceil(8).max(1))
+                .map(|i| (i as u8).wrapping_mul(31).wrapping_add(salt))
+                .collect();
+            BitBufferMut::from_buffer(bytes, offset, len).freeze()
+        };
+        let ops: [fn(u64, u64) -> u64; 4] =
+            [|a, b| a & b, |a, b| a | b, |a, b| a ^ b, |a, b| a & !b];
+
+        for len in [1usize, 5, 8, 63, 64, 65, 129, 200] {
+            let right = make(right_offset, len, 0x5A);
+            for op in ops {
+                // A fresh, uniquely-owned LHS triggers the in-place path when offsets match.
+                let got = bitwise_binary_op_lhs_owned(make(left_offset, len, 0xC3), &right, op);
+                let expected = bitwise_binary_op(&make(left_offset, len, 0xC3), &right, op);
+                assert_eq!(
+                    got, expected,
+                    "loff={left_offset} roff={right_offset} len={len}"
+                );
+            }
+        }
+    }
+
     #[test]
     fn test_bitwise_binary_and() {
         // 0b1111 (15) & 0b1010 (10) = 0b1010 (10)
diff --git a/vortex-buffer/src/bit/view.rs b/vortex-buffer/src/bit/view.rs
new file mode 100644
index 00000000000..722119ee4ab
--- /dev/null
+++ b/vortex-buffer/src/bit/view.rs
@@ -0,0 +1,546 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::ops::Bound;
+use std::ops::RangeBounds;
+
+use crate::BitBuffer;
+use crate::BitBufferMeta;
+use crate::BitBufferMut;
+use crate::ByteBuffer;
+use crate::bit::BitChunks;
+use crate::bit::BitIndexIterator;
+use crate::bit::BitIterator;
+use crate::bit::BitSliceIterator;
+use crate::bit::UnalignedBitChunk;
+use crate::bit::buf_mut::fill_bits;
+use crate::bit::count_ones::count_ones;
+use crate::bit::get_bit_unchecked;
+use crate::bit::select::bit_select;
+use crate::bit::set_bit_unchecked;
+use crate::bit::unset_bit_unchecked;
+
+/// Resolve `start..end` bounds against a logical length, panicking on invalid ranges.
+#[inline]
+fn resolve_range(range: impl RangeBounds<usize>, len: usize) -> (usize, usize) {
+    let start = match range.start_bound() {
+        Bound::Included(&s) => s,
+        Bound::Excluded(&s) => s + 1,
+        Bound::Unbounded => 0,
+    };
+    let end = match range.end_bound() {
+        Bound::Included(&e) => e + 1,
+        Bound::Excluded(&e) => e,
+        Bound::Unbounded => len,
+    };
+
+    assert!(start <= end);
+    assert!(start <= len);
+    assert!(end <= len);
+    (start, end)
+}
+
+/// Normalize a byte slice and bit offset so that the returned offset is `< 8`.
+#[inline]
+fn normalize(buffer: &[u8], offset: usize) -> (&[u8], usize) {
+    let byte_offset = offset / 8;
+    (&buffer[byte_offset..], offset % 8)
+}
+
+/// An immutable, borrowed view over a packed bitset.
+///
+/// This is the borrowing analogue of [`BitBuffer`]: it stores a byte slice together with a bit
+/// `offset` (always `< 8`) and a logical bit `len`, without owning or reference-counting the
+/// backing allocation. Use it to read a bitset without cloning the underlying [`ByteBuffer`].
+#[derive(Debug, Clone, Copy)]
+pub struct BitBufferView<'a> {
+    buffer: &'a [u8],
+    offset: usize,
+    len: usize,
+}
+
+impl<'a> BitBufferView<'a> {
+    /// Create a new view over `buffer` with `len` bits, starting at bit zero.
+    ///
+    /// Panics if the buffer is not large enough to hold `len` bits.
+    pub fn new(buffer: &'a [u8], len: usize) -> Self {
+        Self::new_with_offset(buffer, len, 0)
+    }
+
+    /// Create a new view over `buffer` with `len` bits, starting at the given bit `offset`.
+    ///
+    /// Panics if the buffer is not large enough to hold `len` bits after the offset.
+    pub fn new_with_offset(buffer: &'a [u8], len: usize, offset: usize) -> Self {
+        assert!(
+            len.saturating_add(offset) <= buffer.len().saturating_mul(8),
+            "provided slice (len={}) not large enough to back BitBufferView with offset {offset} len {len}",
+            buffer.len()
+        );
+
+        let (buffer, offset) = normalize(buffer, offset);
+        Self {
+            buffer,
+            offset,
+            len,
+        }
+    }
+
+    /// Create a new view over `buffer` described by `meta`.
+    pub fn from_meta(buffer: &'a [u8], meta: BitBufferMeta) -> Self {
+        Self::new_with_offset(buffer, meta.len(), meta.offset())
+    }
+
+    /// Returns the [`BitBufferMeta`] (offset and length) describing this view.
+    pub fn meta(&self) -> BitBufferMeta {
+        BitBufferMeta::new(self.offset, self.len)
+    }
+
+    /// Get the logical length of this view in bits.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.len
+    }
+
+    /// Returns `true` if the view is empty.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
+    /// Offset of the start of the view in bits. Always `< 8`.
+    #[inline(always)]
+    pub fn offset(&self) -> usize {
+        self.offset
+    }
+
+    /// Get a reference to the underlying byte slice.
+    #[inline(always)]
+    pub fn inner(&self) -> &'a [u8] {
+        self.buffer
+    }
+
+    /// Retrieve the value at the given index.
+    ///
+    /// Panics if the index is out of bounds.
+    #[inline]
+    pub fn value(&self, index: usize) -> bool {
+        assert!(index < self.len);
+        // SAFETY: checked by assertion
+        unsafe { self.value_unchecked(index) }
+    }
+
+    /// Retrieve the value at the given index without bounds checking.
+    ///
+    /// # Safety
+    ///
+    /// Caller must ensure that `index` is within the range of the view.
+    #[inline]
+    pub unsafe fn value_unchecked(&self, index: usize) -> bool {
+        unsafe { get_bit_unchecked(self.buffer.as_ptr(), index + self.offset) }
+    }
+
+    /// Create a new view over the range `[start, end)` of this view.
+    ///
+    /// Panics if the slice would extend beyond the end of the view.
+    pub fn slice(&self, range: impl RangeBounds<usize>) -> BitBufferView<'a> {
+        let (start, end) = resolve_range(range, self.len);
+        BitBufferView::new_with_offset(self.buffer, end - start, self.offset + start)
+    }
+
+    /// Access chunks of the buffer aligned to an 8 byte boundary as
+    /// `[prefix, <full chunks>, suffix]`.
+    pub fn unaligned_chunks(&self) -> UnalignedBitChunk<'a> {
+        UnalignedBitChunk::new(self.buffer, self.offset, self.len)
+    }
+
+    /// Access chunks of the underlying buffer as 8 byte chunks with a final trailer.
+    pub fn chunks(&self) -> BitChunks<'a> {
+        BitChunks::new(self.buffer, self.offset, self.len)
+    }
+
+    /// Get the number of set bits in the view.
+    pub fn true_count(&self) -> usize {
+        count_ones(self.buffer, self.offset, self.len)
+    }
+
+    /// Get the number of unset bits in the view.
+    pub fn false_count(&self) -> usize {
+        self.len - self.true_count()
+    }
+
+    /// Returns the position of the `nth` set bit (0-indexed), or `None` if out of range.
+    pub fn select(&self, nth: usize) -> Option<usize> {
+        bit_select(self.buffer, self.offset, self.len, nth)
+    }
+
+    /// Iterator over bits in the view.
+    pub fn iter(&self) -> BitIterator<'a> {
+        BitIterator::new(self.buffer, self.offset, self.len)
+    }
+
+    /// Iterator over set indices of the underlying buffer.
+    pub fn set_indices(&self) -> BitIndexIterator<'a> {
+        BitIndexIterator::new(self.buffer, self.offset, self.len)
+    }
+
+    /// Iterator over set slices of the underlying buffer.
+    pub fn set_slices(&self) -> BitSliceIterator<'a> {
+        BitSliceIterator::new(self.buffer, self.offset, self.len)
+    }
+
+    /// Copy this view into an owned [`BitBuffer`].
+    pub fn to_bit_buffer(&self) -> BitBuffer {
+        let bytes = (self.offset + self.len).div_ceil(8);
+        BitBuffer::new_with_offset(
+            ByteBuffer::copy_from(&self.buffer[..bytes]),
+            self.len,
+            self.offset,
+        )
+    }
+}
+
+impl<'a> IntoIterator for BitBufferView<'a> {
+    type Item = bool;
+    type IntoIter = BitIterator<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+impl PartialEq for BitBufferView<'_> {
+    fn eq(&self, other: &Self) -> bool {
+        if self.len != other.len {
+            return false;
+        }
+
+        self.chunks()
+            .iter_padded()
+            .zip(other.chunks().iter_padded())
+            .all(|(a, b)| a == b)
+    }
+}
+
+impl Eq for BitBufferView<'_> {}
+
+/// A mutable, borrowed view over a packed bitset.
+///
+/// This is the borrowing analogue of [`BitBufferMut`]: it stores a mutable byte slice together
+/// with a bit `offset` (always `< 8`) and a logical bit `len`. Unlike [`BitBufferMut`] it cannot
+/// grow or reallocate, so it only supports in-place reads and writes (such as
+/// [`set`](Self::set), [`unset`](Self::unset), and [`fill_range`](Self::fill_range)).
+#[derive(Debug)]
+pub struct BitBufferMutView<'a> {
+    buffer: &'a mut [u8],
+    offset: usize,
+    len: usize,
+}
+
+impl<'a> BitBufferMutView<'a> {
+    /// Create a new mutable view over `buffer` with `len` bits, starting at bit zero.
+    ///
+    /// Panics if the buffer is not large enough to hold `len` bits.
+    pub fn new(buffer: &'a mut [u8], len: usize) -> Self {
+        Self::new_with_offset(buffer, len, 0)
+    }
+
+    /// Create a new mutable view over `buffer` with `len` bits, starting at bit `offset`.
+    ///
+    /// Panics if the buffer is not large enough to hold `len` bits after the offset.
+    pub fn new_with_offset(buffer: &'a mut [u8], len: usize, offset: usize) -> Self {
+        assert!(
+            len.saturating_add(offset) <= buffer.len().saturating_mul(8),
+            "provided slice (len={}) not large enough to back BitBufferMutView with offset {offset} len {len}",
+            buffer.len()
+        );
+
+        let byte_offset = offset / 8;
+        let offset = offset % 8;
+        Self {
+            buffer: &mut buffer[byte_offset..],
+            offset,
+            len,
+        }
+    }
+
+    /// Borrow this mutable view as an immutable [`BitBufferView`].
+    #[inline]
+    pub fn as_view(&self) -> BitBufferView<'_> {
+        BitBufferView {
+            buffer: self.buffer,
+            offset: self.offset,
+            len: self.len,
+        }
+    }
+
+    /// Get the logical length of this view in bits.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.len
+    }
+
+    /// Returns `true` if the view is empty.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
+    /// Offset of the start of the view in bits. Always `< 8`.
+    #[inline(always)]
+    pub fn offset(&self) -> usize {
+        self.offset
+    }
+
+    /// Get the underlying bytes as a slice.
+    #[inline]
+    pub fn as_slice(&self) -> &[u8] {
+        self.buffer
+    }
+
+    /// Get the underlying bytes as a mutable slice.
+    #[inline]
+    pub fn as_mut_slice(&mut self) -> &mut [u8] {
+        self.buffer
+    }
+
+    /// Retrieve the value at the given index.
+    ///
+    /// Panics if the index is out of bounds.
+    #[inline]
+    pub fn value(&self, index: usize) -> bool {
+        assert!(index < self.len);
+        // SAFETY: checked by assertion
+        unsafe { self.value_unchecked(index) }
+    }
+
+    /// Retrieve the value at the given index without bounds checking.
+    ///
+    /// # Safety
+    ///
+    /// Caller must ensure that `index` is within the range of the view.
+    #[inline]
+    pub unsafe fn value_unchecked(&self, index: usize) -> bool {
+        unsafe { get_bit_unchecked(self.buffer.as_ptr(), index + self.offset) }
+    }
+
+    /// Get the number of set bits in the view.
+    pub fn true_count(&self) -> usize {
+        self.as_view().true_count()
+    }
+
+    /// Get the number of unset bits in the view.
+    pub fn false_count(&self) -> usize {
+        self.as_view().false_count()
+    }
+
+    /// Iterator over bits in the view.
+    pub fn iter(&self) -> BitIterator<'_> {
+        self.as_view().iter()
+    }
+
+    /// Set the bit at `index` to the given boolean value.
+    ///
+    /// Panics if `index` exceeds the view length.
+    pub fn set_to(&mut self, index: usize, value: bool) {
+        if value {
+            self.set(index);
+        } else {
+            self.unset(index);
+        }
+    }
+
+    /// Set the bit at `index` to the given boolean value without bounds checking.
+    ///
+    /// # Safety
+    ///
+    /// Caller must ensure that `index` is within the range of the view.
+    pub unsafe fn set_to_unchecked(&mut self, index: usize, value: bool) {
+        if value {
+            // SAFETY: checked by caller
+            unsafe { self.set_unchecked(index) }
+        } else {
+            // SAFETY: checked by caller
+            unsafe { self.unset_unchecked(index) }
+        }
+    }
+
+    /// Set the bit at `index` to `true`.
+    ///
+    /// Panics if `index` exceeds the view length.
+    pub fn set(&mut self, index: usize) {
+        assert!(index < self.len, "index {index} exceeds len {}", self.len);
+        // SAFETY: checked by assertion
+        unsafe { self.set_unchecked(index) };
+    }
+
+    /// Set the bit at `index` to `false`.
+    ///
+    /// Panics if `index` exceeds the view length.
+    pub fn unset(&mut self, index: usize) {
+        assert!(index < self.len, "index {index} exceeds len {}", self.len);
+        // SAFETY: checked by assertion
+        unsafe { self.unset_unchecked(index) };
+    }
+
+    /// Set the bit at `index` to `true` without bounds checking.
+    ///
+    /// # Safety
+    ///
+    /// Caller must ensure that `index` is within the range of the view.
+    #[inline]
+    pub unsafe fn set_unchecked(&mut self, index: usize) {
+        // SAFETY: checked by caller
+        unsafe { set_bit_unchecked(self.buffer.as_mut_ptr(), self.offset + index) }
+    }
+
+    /// Set the bit at `index` to `false` without bounds checking.
+    ///
+    /// # Safety
+    ///
+    /// Caller must ensure that `index` is within the range of the view.
+    #[inline]
+    pub unsafe fn unset_unchecked(&mut self, index: usize) {
+        // SAFETY: checked by caller
+        unsafe { unset_bit_unchecked(self.buffer.as_mut_ptr(), self.offset + index) }
+    }
+
+    /// Sets all bits in the range `[start, end)` to `value`.
+    ///
+    /// Panics if `end > self.len()` or `start > end`.
+    #[inline(always)]
+    pub fn fill_range(&mut self, start: usize, end: usize, value: bool) {
+        assert!(end <= self.len, "end {end} exceeds len {}", self.len);
+        assert!(start <= end, "start {start} exceeds end {end}");
+        // SAFETY: assertions guarantee start <= end <= self.len.
+        unsafe { self.fill_range_unchecked(start, end, value) }
+    }
+
+    /// Sets all bits in the range `[start, end)` to `value` without bounds checking.
+    ///
+    /// # Safety
+    ///
+    /// Caller must ensure that `start <= end <= self.len()`.
+    #[inline(always)]
+    pub unsafe fn fill_range_unchecked(&mut self, start: usize, end: usize, value: bool) {
+        fill_bits(self.buffer, self.offset + start, self.offset + end, value);
+    }
+
+    /// Copy this view into an owned [`BitBuffer`].
+    pub fn to_bit_buffer(&self) -> BitBuffer {
+        self.as_view().to_bit_buffer()
+    }
+}
+
+impl BitBuffer {
+    /// Borrow this buffer as a [`BitBufferView`] without cloning the backing allocation.
+    #[inline]
+    pub fn as_view(&self) -> BitBufferView<'_> {
+        BitBufferView {
+            buffer: self.inner().as_slice(),
+            offset: self.offset(),
+            len: self.len(),
+        }
+    }
+}
+
+impl BitBufferMut {
+    /// Borrow this buffer as an immutable [`BitBufferView`].
+    #[inline]
+    pub fn as_view(&self) -> BitBufferView<'_> {
+        BitBufferView {
+            buffer: self.as_slice(),
+            offset: self.offset(),
+            len: self.len(),
+        }
+    }
+
+    /// Borrow this buffer as a [`BitBufferMutView`].
+    #[inline]
+    pub fn as_mut_view(&mut self) -> BitBufferMutView<'_> {
+        let offset = self.offset();
+        let len = self.len();
+        BitBufferMutView {
+            buffer: self.as_mut_slice(),
+            offset,
+            len,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::BitBuffer;
+    use crate::BitBufferMut;
+    use crate::bitbuffer;
+
+    #[test]
+    fn view_reads_match_buffer() {
+        let buffer = bitbuffer![true, false, true, true, false, true, false, false];
+        let view = buffer.as_view();
+
+        assert_eq!(view.len(), buffer.len());
+        assert_eq!(view.true_count(), buffer.true_count());
+        assert_eq!(view.false_count(), buffer.false_count());
+        for i in 0..buffer.len() {
+            assert_eq!(view.value(i), buffer.value(i));
+        }
+        assert_eq!(
+            view.iter().collect::<Vec<_>>(),
+            buffer.iter().collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn view_slice_preserves_offset() {
+        let buffer = BitBuffer::new_set(20);
+        let sliced = buffer.slice(5..17);
+        let view = buffer.as_view().slice(5..17);
+
+        assert_eq!(view.len(), sliced.len());
+        assert_eq!(view.true_count(), sliced.true_count());
+        assert_eq!(view.to_bit_buffer(), sliced);
+    }
+
+    #[test]
+    fn view_offset_buffer() {
+        let buffer = BitBuffer::new_set(64).slice(3..40);
+        let view = buffer.as_view();
+        assert_eq!(view.offset(), buffer.offset());
+        assert_eq!(view.len(), buffer.len());
+        assert_eq!(view.to_bit_buffer(), buffer);
+    }
+
+    #[test]
+    fn mut_view_set_unset() {
+        let mut buffer = BitBufferMut::new_unset(16);
+        {
+            let mut view = buffer.as_mut_view();
+            view.set(0);
+            view.set(15);
+            view.set_to(7, true);
+            view.fill_range(2, 5, true);
+            assert!(view.value(0));
+            assert_eq!(view.true_count(), 6);
+            view.unset(0);
+        }
+        let frozen = buffer.freeze();
+        assert!(!frozen.value(0));
+        assert!(frozen.value(2));
+        assert!(frozen.value(4));
+        assert!(frozen.value(7));
+        assert!(frozen.value(15));
+        assert_eq!(frozen.true_count(), 5);
+    }
+
+    #[test]
+    fn mut_view_with_offset() {
+        let mut buffer = BitBufferMut::from_buffer(crate::buffer_mut![0u8; 4], 3, 20);
+        {
+            let mut view = buffer.as_mut_view();
+            assert_eq!(view.offset(), 3);
+            view.fill_range(0, 20, true);
+        }
+        let frozen = buffer.freeze();
+        assert_eq!(frozen.true_count(), 20);
+    }
+}
diff --git a/vortex-compressor/benches/dict_encode.rs b/vortex-compressor/benches/dict_encode.rs
index b3314008c03..68b7cd98013 100644
--- a/vortex-compressor/benches/dict_encode.rs
+++ b/vortex-compressor/benches/dict_encode.rs
@@ -3,17 +3,23 @@
 
 #![expect(clippy::unwrap_used)]
 
+use std::sync::LazyLock;
+
 use divan::Bencher;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::BoolArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::builders::dict::dict_encode;
+use vortex_array::session::ArraySession;
 use vortex_array::validity::Validity;
 use vortex_buffer::BufferMut;
 use vortex_compressor::builtins::integer_dictionary_encode;
 use vortex_compressor::stats::IntegerStats;
+use vortex_session::VortexSession;
+
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
 
 fn make_array() -> PrimitiveArray {
     let values: BufferMut<i32> = (0..50).cycle().take(64_000).collect();
@@ -33,16 +39,16 @@ fn make_array() -> PrimitiveArray {
 #[divan::bench]
 fn encode_generic(bencher: Bencher) {
     let array = make_array().into_array();
-    bencher.with_inputs(|| &array).bench_refs(|array| {
-        dict_encode(array, &mut LEGACY_SESSION.create_execution_ctx()).unwrap()
-    });
+    bencher
+        .with_inputs(|| (&array, SESSION.create_execution_ctx()))
+        .bench_refs(|(array, ctx)| dict_encode(array, ctx).unwrap());
 }
 
 #[cfg(not(codspeed))]
 #[divan::bench]
 fn encode_specialized(bencher: Bencher) {
     let array = make_array();
-    let stats = IntegerStats::generate(&array, &mut LEGACY_SESSION.create_execution_ctx());
+    let stats = IntegerStats::generate(&array, &mut SESSION.create_execution_ctx());
     bencher
         .with_inputs(|| &stats)
         .bench_refs(|stats| integer_dictionary_encode(array.as_view(), stats));
diff --git a/vortex-compressor/benches/stats_calc.rs b/vortex-compressor/benches/stats_calc.rs
index c93a8373801..69a8f970608 100644
--- a/vortex-compressor/benches/stats_calc.rs
+++ b/vortex-compressor/benches/stats_calc.rs
@@ -4,15 +4,21 @@
 #[cfg(not(codspeed))]
 #[divan::bench_group(items_count = 64_000u32, bytes_count = 256_000u32)]
 mod benchmarks {
+    use std::sync::LazyLock;
+
     use divan::Bencher;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::session::ArraySession;
     use vortex_array::validity::Validity;
     use vortex_buffer::Buffer;
     use vortex_buffer::BufferMut;
     use vortex_compressor::stats::GenerateStatsOptions;
     use vortex_compressor::stats::IntegerStats;
+    use vortex_session::VortexSession;
+
+    static SESSION: LazyLock<VortexSession> =
+        LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
 
     fn generate_dataset(max_run: u32, distinct: u32) -> Buffer<u32> {
         let mut output = BufferMut::with_capacity(64_000);
@@ -56,7 +62,7 @@ mod benchmarks {
         };
 
         bencher
-            .with_inputs(|| (&values, LEGACY_SESSION.create_execution_ctx()))
+            .with_inputs(|| (&values, SESSION.create_execution_ctx()))
             .bench_refs(|(values, ctx)| {
                 IntegerStats::generate_opts(values, GenerateStatsOptions::default(), ctx);
             });
@@ -71,7 +77,7 @@ mod benchmarks {
         };
 
         bencher
-            .with_inputs(|| (&values, LEGACY_SESSION.create_execution_ctx()))
+            .with_inputs(|| (&values, SESSION.create_execution_ctx()))
             .bench_refs(|(values, ctx)| {
                 IntegerStats::generate_opts(
                     values,
diff --git a/vortex-compressor/src/compressor.rs b/vortex-compressor/src/compressor.rs
index a557736573a..33502104b13 100644
--- a/vortex-compressor/src/compressor.rs
+++ b/vortex-compressor/src/compressor.rs
@@ -120,7 +120,7 @@ impl CascadingCompressor {
         let _enter = span.enter();
 
         let canonical = array.clone().execute::<CanonicalValidity>(exec_ctx)?.0;
-        let compact = canonical.compact()?;
+        let compact = canonical.compact(exec_ctx)?;
         let compressed = self.compress_canonical(compact, CompressorContext::new(), exec_ctx)?;
 
         trace::record_compress_outcome(&span, before_nbytes, compressed.nbytes());
@@ -151,7 +151,7 @@ impl CascadingCompressor {
         }
 
         let canonical = child.clone().execute::<CanonicalValidity>(exec_ctx)?.0;
-        let compact = canonical.compact()?;
+        let compact = canonical.compact(exec_ctx)?;
 
         let child_ctx = parent_ctx
             .clone()
@@ -197,7 +197,7 @@ impl CascadingCompressor {
             }
             Canonical::List(list_view_array) => {
                 if list_view_array.is_zero_copy_to_list() || list_view_array.elements().is_empty() {
-                    let list_array = list_from_list_view(list_view_array)?;
+                    let list_array = list_from_list_view(list_view_array, exec_ctx)?;
                     self.compress_list_array(list_array, compress_ctx, exec_ctx)
                 } else {
                     self.compress_list_view_array(list_view_array, compress_ctx, exec_ctx)
@@ -495,7 +495,7 @@ impl CascadingCompressor {
         compress_ctx: CompressorContext,
         exec_ctx: &mut ExecutionCtx,
     ) -> VortexResult<ArrayRef> {
-        let list_array = list_array.reset_offsets(true)?;
+        let list_array = list_array.reset_offsets(true, exec_ctx)?;
 
         let compressed_elems = self.compress(list_array.elements(), exec_ctx)?;
 
diff --git a/vortex-compressor/src/stats/cache.rs b/vortex-compressor/src/stats/cache.rs
index 66ab655728c..2652403d3e6 100644
--- a/vortex-compressor/src/stats/cache.rs
+++ b/vortex-compressor/src/stats/cache.rs
@@ -28,7 +28,7 @@ type StatsEntry = (TypeId, Arc<dyn Any + Send + Sync>);
 
 /// Cache for compression statistics, keyed by concrete type.
 ///
-/// The cache is interior-mutable: entries can be inserted through a shared [`&StatsCache`]
+/// The cache is interior-mutable: entries can be inserted through a shared [`StatsCache`]
 /// borrow. Values are stored as [`Arc<dyn Any + Send + Sync>`] so that cached entries can be
 /// cloned out of the lock cheaply and handed back to callers as [`Arc<T>`].
 struct StatsCache {
diff --git a/vortex-cuda/Cargo.toml b/vortex-cuda/Cargo.toml
index d540c54b7e6..c4c083b97a3 100644
--- a/vortex-cuda/Cargo.toml
+++ b/vortex-cuda/Cargo.toml
@@ -104,3 +104,15 @@ harness = false
 [[bench]]
 name = "fsst_cuda"
 harness = false
+
+[[bench]]
+name = "list_view_cuda"
+harness = false
+
+[[bench]]
+name = "arrow_validity_cuda"
+harness = false
+
+[[bench]]
+name = "arrow_binary_cuda"
+harness = false
diff --git a/vortex-cuda/README.md b/vortex-cuda/README.md
index 1579bececdc..24b8f420290 100644
--- a/vortex-cuda/README.md
+++ b/vortex-cuda/README.md
@@ -10,35 +10,27 @@ Key files:
 - `vortex-cuda/src/arrow/canonical.rs`: canonical-array export to `ArrowDeviceArray`.
 - `vortex-test/e2e-cuda/src/lib.rs`: cuDF interop harness.
 
-Current export coverage includes primitive, bool, decimal/temporal, string/binary view, and struct arrays. Remaining work includes null masks, broader dtype coverage, `ArrowDeviceArrayStream`, and PyVortex integration.
+## Building cuDF for Arrow Device interop
 
-## cuDF compatibility
+The `cudf-test-harness` repository provides prebuilt cuDF binaries for Arrow Device interop testing on
+x86_64 and aarch64.
 
-Vortex exports string and binary columns as Arrow `Utf8View` / `BinaryView` device arrays with producer-owned `ArrowArray.private_data`. cuDF string/binary interop requires a build containing `rapidsai/cudf#22620`; until a release version is identified, test with a cuDF commit that includes that change.
-
-## Building cuDF for interop testing
-
-Pass a single CUDA architecture, e.g. `-DCMAKE_CUDA_ARCHITECTURES=90a`; otherwise cuDF builds for many architectures and local builds are much slower.
+From the cuDF repository root, compile the Arrow Device interop target locally without exporting additional
+environment variables:
 
 ```sh
-export PATH=/usr/local/cuda-13.1/bin:$PATH
+cmake -E rm -rf cpp/build
 
 cmake -S cpp -B cpp/build \
-  -DCMAKE_INSTALL_PREFIX=${CONDA_PREFIX:-/usr/local} \
-  -DCMAKE_CUDA_ARCHITECTURES=90a \
+  -DCMAKE_INSTALL_PREFIX=/usr/local \
+  -DCMAKE_CUDA_ARCHITECTURES=NATIVE \
   -DBUILD_TESTS=ON \
   -DDISABLE_DEPRECATION_WARNINGS=ON \
   -DCMAKE_BUILD_TYPE=Debug \
   -DCUDF_BUILD_STREAMS_TEST_UTIL=OFF \
-  -DCUDAToolkit_ROOT=/usr/local/cuda-13.1 \
-  -DCMAKE_CUDA_COMPILER=/usr/local/cuda-13.1/bin/nvcc \
-  -DCMAKE_CXX_COMPILER=/usr/bin/g++-13 \
-  -DCMAKE_C_COMPILER=/usr/bin/gcc-13 \
-  -GNinja
-
-cmake --build cpp/build --target INTEROP_TEST -j$(nproc)
-
-LD_LIBRARY_PATH=/usr/local/cuda-13.1/compat:$LD_LIBRARY_PATH ./cpp/build/gtests/INTEROP_TEST
+  -DCUDAToolkit_ROOT=/usr/local/cuda \
+  -DCMAKE_CUDA_COMPILER=/usr/local/cuda/bin/nvcc \
+  -DCMAKE_C_COMPILER=gcc \
+  -DCMAKE_CXX_COMPILER=g++ \
+  -GNinja && cmake --build cpp/build --target INTEROP_TEST --parallel
 ```
-
-Adjust architecture, compiler paths, and CUDA paths for the machine under test.
diff --git a/vortex-cuda/benches/arrow_binary_cuda.rs b/vortex-cuda/benches/arrow_binary_cuda.rs
new file mode 100644
index 00000000000..bd3154e471a
--- /dev/null
+++ b/vortex-cuda/benches/arrow_binary_cuda.rs
@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! CUDA kernel-time benchmark for Arrow Device export of binary view arrays as Arrow Binary.
+
+#![expect(clippy::cast_possible_truncation)]
+
+#[allow(dead_code)]
+mod bench_config;
+mod timed_launch_strategy;
+
+use std::sync::Arc;
+use std::sync::atomic::Ordering;
+use std::time::Duration;
+
+use criterion::BenchmarkId;
+use criterion::Criterion;
+use criterion::Throughput;
+use futures::executor::block_on;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::arrays::VarBinViewArray;
+use vortex::array::arrays::varbinview::BinaryView;
+use vortex::array::buffer::BufferHandle;
+use vortex::array::validity::Validity;
+use vortex::buffer::Buffer;
+use vortex::buffer::ByteBuffer;
+use vortex::dtype::DType;
+use vortex::dtype::Nullability;
+use vortex::error::VortexExpect;
+use vortex::error::VortexResult;
+use vortex::session::VortexSession;
+use vortex_cuda::CudaExecutionCtx;
+use vortex_cuda::CudaSession;
+use vortex_cuda::arrow::ArrowDeviceArray;
+use vortex_cuda::arrow::DeviceArrayExt;
+use vortex_cuda_macros::cuda_available;
+use vortex_cuda_macros::cuda_not_available;
+
+use crate::timed_launch_strategy::TimedLaunchStrategy;
+
+const BINARY_BENCH_SIZES: &[(usize, &str)] = &[(10_000_000, "10M")];
+const VALUE_BYTES: usize = 16;
+
+/// Build a non-nullable binary view array of `len` out-of-line values on the device.
+async fn out_of_line_binary(len: usize, ctx: &mut CudaExecutionCtx) -> VortexResult<ArrayRef> {
+    let values = ByteBuffer::copy_from(vec![b'x'; len * VALUE_BYTES]);
+    let views = Buffer::from_iter((0..len).map(|idx| {
+        let offset = idx * VALUE_BYTES;
+        BinaryView::make_view(
+            &values.slice(offset..offset + VALUE_BYTES),
+            0,
+            offset as u32,
+        )
+    }));
+
+    let views = ctx
+        .ensure_on_device(BufferHandle::new_host(views.into_byte_buffer()))
+        .await?;
+    let values = ctx.ensure_on_device(BufferHandle::new_host(values)).await?;
+
+    Ok(VarBinViewArray::new_handle(
+        views,
+        Arc::from([values]),
+        DType::Binary(Nullability::NonNullable),
+        Validity::NonNullable,
+    )
+    .into_array())
+}
+
+unsafe fn release_arrow_device_array(array: &mut ArrowDeviceArray) {
+    unsafe {
+        if let Some(release) = array.array.release {
+            release(&raw mut array.array);
+        }
+    }
+}
+
+fn benchmark_arrow_binary_export(c: &mut Criterion) {
+    let mut group = c.benchmark_group("cuda");
+
+    for &(len, len_label) in BINARY_BENCH_SIZES {
+        // Kernels read views and value bytes and write offsets plus gathered values.
+        group.throughput(Throughput::Bytes(
+            (len * (size_of::<BinaryView>() + VALUE_BYTES + size_of::<i32>())) as u64,
+        ));
+        group.bench_with_input(
+            BenchmarkId::new("cuda/arrow_binary_kernel_time/out_of_line", len_label),
+            &len,
+            |b, &len| {
+                b.iter_custom(|iters| {
+                    let timed = TimedLaunchStrategy::default();
+                    let timer = timed.timer();
+
+                    let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+                        .vortex_expect("failed to create execution context")
+                        .with_launch_strategy(Arc::new(timed));
+                    let array = block_on(out_of_line_binary(len, &mut cuda_ctx))
+                        .vortex_expect("failed to create binary fixture");
+
+                    for _ in 0..iters {
+                        let mut exported =
+                            block_on(array.clone().export_device_array(&mut cuda_ctx))
+                                .vortex_expect("failed to export device array");
+                        unsafe { release_arrow_device_array(&mut exported) };
+                    }
+
+                    Duration::from_nanos(timer.load(Ordering::Relaxed))
+                });
+            },
+        );
+    }
+
+    group.finish();
+}
+
+criterion::criterion_group! {
+    name = benches;
+    config = bench_config::cuda_bench_config();
+    targets = benchmark_arrow_binary_export
+}
+
+#[cuda_available]
+criterion::criterion_main!(benches);
+
+#[cuda_not_available]
+fn main() {}
diff --git a/vortex-cuda/benches/arrow_validity_cuda.rs b/vortex-cuda/benches/arrow_validity_cuda.rs
new file mode 100644
index 00000000000..9221d7c0698
--- /dev/null
+++ b/vortex-cuda/benches/arrow_validity_cuda.rs
@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! CUDA benchmarks for Arrow validity bitmap repacking.
+
+mod bench_config;
+mod timed_launch_strategy;
+
+use std::sync::Arc;
+use std::sync::atomic::Ordering;
+use std::time::Duration;
+
+use criterion::BenchmarkId;
+use criterion::Criterion;
+use criterion::Throughput;
+use futures::executor::block_on;
+use vortex::array::buffer::BufferHandle;
+use vortex::buffer::BitBuffer;
+use vortex::error::VortexExpect;
+use vortex::session::VortexSession;
+use vortex_cuda::CudaSession;
+use vortex_cuda::arrow::test_harness;
+use vortex_cuda_macros::cuda_available;
+use vortex_cuda_macros::cuda_not_available;
+
+use crate::timed_launch_strategy::TimedLaunchStrategy;
+
+const INPUT_OFFSET: usize = 5;
+const ARROW_OFFSET: usize = 3;
+
+fn benchmark_arrow_validity_repack(c: &mut Criterion) {
+    let mut group = c.benchmark_group("cuda");
+
+    for &(len, len_label) in bench_config::BENCH_SIZES {
+        group.throughput(Throughput::Elements(len as u64));
+        group.bench_with_input(
+            BenchmarkId::new("cuda/arrow_validity/repack", len_label),
+            &len,
+            |b, &len| {
+                b.iter_custom(|iters| {
+                    let timed = TimedLaunchStrategy::default();
+                    let timer = timed.timer();
+
+                    let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+                        .vortex_expect("failed to create execution context")
+                        .with_launch_strategy(Arc::new(timed));
+                    let source = BitBuffer::collect_bool(len + INPUT_OFFSET, |idx| idx % 3 != 0);
+                    let sliced = source.slice(INPUT_OFFSET..INPUT_OFFSET + len);
+                    let (input_offset, _, input_buffer) = sliced.into_inner();
+                    let input_buffer =
+                        block_on(cuda_ctx.ensure_on_device(BufferHandle::new_host(input_buffer)))
+                            .vortex_expect("failed to copy validity input to device");
+
+                    for _ in 0..iters {
+                        let output = test_harness::repack_arrow_validity_buffer(
+                            &input_buffer,
+                            input_offset,
+                            len,
+                            ARROW_OFFSET,
+                            &mut cuda_ctx,
+                        )
+                        .vortex_expect("failed to repack Arrow validity");
+                        std::hint::black_box(output);
+                    }
+
+                    Duration::from_nanos(timer.load(Ordering::Relaxed))
+                });
+            },
+        );
+    }
+
+    group.finish();
+}
+
+criterion::criterion_group! {
+    name = benches;
+    config = bench_config::cuda_bench_config();
+    targets = benchmark_arrow_validity_repack
+}
+
+#[cuda_available]
+criterion::criterion_main!(benches);
+
+#[cuda_not_available]
+fn main() {}
diff --git a/vortex-cuda/benches/list_view_cuda.rs b/vortex-cuda/benches/list_view_cuda.rs
new file mode 100644
index 00000000000..0904844b900
--- /dev/null
+++ b/vortex-cuda/benches/list_view_cuda.rs
@@ -0,0 +1,155 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! CUDA benchmarks for Arrow Device export of Vortex list-view arrays.
+
+#![expect(clippy::cast_possible_truncation)]
+
+#[allow(dead_code)]
+mod bench_config;
+mod timed_launch_strategy;
+
+use std::sync::Arc;
+use std::sync::atomic::Ordering;
+use std::time::Duration;
+
+use criterion::BenchmarkId;
+use criterion::Criterion;
+use criterion::Throughput;
+use futures::executor::block_on;
+use vortex::array::ArrayRef;
+use vortex::array::IntoArray;
+use vortex::array::arrays::ListViewArray;
+use vortex::array::arrays::PrimitiveArray;
+use vortex::array::validity::Validity;
+use vortex::dtype::PType;
+use vortex::error::VortexExpect;
+use vortex::error::VortexResult;
+use vortex::session::VortexSession;
+use vortex_cuda::CudaExecutionCtx;
+use vortex_cuda::CudaSession;
+use vortex_cuda::arrow::ArrowDeviceArray;
+use vortex_cuda::arrow::DeviceArrayExt;
+use vortex_cuda_macros::cuda_available;
+use vortex_cuda_macros::cuda_not_available;
+
+use crate::timed_launch_strategy::TimedLaunchStrategy;
+
+const LIST_VIEW_CONTIGUOUS_BENCH_SIZES: &[(usize, &str)] = &[(10_000_000, "10M")];
+const LIST_VIEW_REBUILD_BENCH_SIZES: &[(usize, &str)] = &[(10_000_000, "10M")];
+
+async fn primitive_i32_on_device(
+    values: impl IntoIterator<Item = i32>,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<ArrayRef> {
+    let primitive = PrimitiveArray::from_iter(values);
+    let handle = ctx
+        .ensure_on_device(primitive.buffer_handle().clone())
+        .await?;
+    Ok(PrimitiveArray::from_buffer_handle(handle, PType::I32, Validity::NonNullable).into_array())
+}
+
+async fn contiguous_list_view(len: usize, ctx: &mut CudaExecutionCtx) -> VortexResult<ArrayRef> {
+    let elements = primitive_i32_on_device((0..len).map(|value| value as i32), ctx).await?;
+    let offsets = primitive_i32_on_device((0..len).map(|value| value as i32), ctx).await?;
+    let sizes = primitive_i32_on_device(std::iter::repeat_n(1i32, len), ctx).await?;
+
+    Ok(ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array())
+}
+
+async fn non_contiguous_primitive_list_view(
+    len: usize,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<ArrayRef> {
+    let elements = primitive_i32_on_device((0..len).map(|value| value as i32), ctx).await?;
+    let offsets = primitive_i32_on_device((0..len).rev().map(|value| value as i32), ctx).await?;
+    let sizes = primitive_i32_on_device(std::iter::repeat_n(1i32, len), ctx).await?;
+
+    Ok(ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array())
+}
+
+unsafe fn release_arrow_device_array(array: &mut ArrowDeviceArray) {
+    unsafe {
+        if let Some(release) = array.array.release {
+            release(&raw mut array.array);
+        }
+    }
+}
+
+fn benchmark_list_view_export(c: &mut Criterion) {
+    let mut group = c.benchmark_group("cuda");
+
+    for &(len, len_label) in LIST_VIEW_CONTIGUOUS_BENCH_SIZES {
+        // Contiguous path reads offsets/sizes and writes Arrow offsets.
+        group.throughput(Throughput::Bytes((len * size_of::<i32>() * 3) as u64));
+        group.bench_with_input(
+            BenchmarkId::new("cuda/list_view/contiguous_offsets", len_label),
+            &len,
+            |b, &len| {
+                b.iter_custom(|iters| {
+                    let timed = TimedLaunchStrategy::default();
+                    let timer = timed.timer();
+
+                    let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+                        .vortex_expect("failed to create execution context")
+                        .with_launch_strategy(Arc::new(timed));
+                    let array = block_on(contiguous_list_view(len, &mut cuda_ctx))
+                        .vortex_expect("failed to create list-view fixture");
+
+                    for _ in 0..iters {
+                        let mut exported =
+                            block_on(array.clone().export_device_array(&mut cuda_ctx))
+                                .vortex_expect("failed to export device array");
+                        unsafe { release_arrow_device_array(&mut exported) };
+                    }
+
+                    Duration::from_nanos(timer.load(Ordering::Relaxed))
+                });
+            },
+        );
+    }
+
+    for &(len, len_label) in LIST_VIEW_REBUILD_BENCH_SIZES {
+        // Rebuild path scans sizes into Arrow offsets, then gathers primitive child values.
+        group.throughput(Throughput::Bytes((len * size_of::<i32>() * 4) as u64));
+        group.bench_with_input(
+            BenchmarkId::new("cuda/list_view/rebuild_primitive", len_label),
+            &len,
+            |b, &len| {
+                b.iter_custom(|iters| {
+                    let timed = TimedLaunchStrategy::default();
+                    let timer = timed.timer();
+
+                    let mut cuda_ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+                        .vortex_expect("failed to create execution context")
+                        .with_launch_strategy(Arc::new(timed));
+                    let array = block_on(non_contiguous_primitive_list_view(len, &mut cuda_ctx))
+                        .vortex_expect("failed to create list-view fixture");
+
+                    for _ in 0..iters {
+                        let mut exported =
+                            block_on(array.clone().export_device_array(&mut cuda_ctx))
+                                .vortex_expect("failed to export device array");
+                        unsafe { release_arrow_device_array(&mut exported) };
+                    }
+
+                    Duration::from_nanos(timer.load(Ordering::Relaxed))
+                });
+            },
+        );
+    }
+
+    group.finish();
+}
+
+criterion::criterion_group! {
+    name = benches;
+    config = bench_config::cuda_bench_config();
+    targets = benchmark_list_view_export
+}
+
+#[cuda_available]
+criterion::criterion_main!(benches);
+
+#[cuda_not_available]
+fn main() {}
diff --git a/vortex-cuda/cub/build.rs b/vortex-cuda/cub/build.rs
index 16b758a57dd..5888d9234dd 100644
--- a/vortex-cuda/cub/build.rs
+++ b/vortex-cuda/cub/build.rs
@@ -101,6 +101,7 @@ fn generate_rust_bindings(kernels_dir: &Path, out_dir: &Path) {
         .allowlist_function("filter_temp_size_.*")
         .allowlist_function("filter_bytemask_.*")
         .allowlist_function("filter_bitmask_.*")
+        .allowlist_function("scan_exclusive_sum_.*")
         // Allow CUDA types
         .allowlist_type("cudaError_t")
         // Blocklist cudaStream_t and define it manually as an opaque pointer
diff --git a/vortex-cuda/cub/kernels/filter.cu b/vortex-cuda/cub/kernels/filter.cu
index 756bbf3c23f..73726b3a4a4 100644
--- a/vortex-cuda/cub/kernels/filter.cu
+++ b/vortex-cuda/cub/kernels/filter.cu
@@ -188,3 +188,33 @@ DEFINE_FILTER_BITMASK(f32, float)
 DEFINE_FILTER_BITMASK(f64, double)
 DEFINE_FILTER_BITMASK(i128, __int128_t)
 DEFINE_FILTER_BITMASK(i256, __int256_t)
+
+// Query CUB temporary storage for an exclusive-sum scan.
+template <typename T>
+static cudaError_t scan_exclusive_sum_temp_size_impl(size_t *temp_bytes, int64_t num_items) {
+    size_t bytes = 0;
+    cudaError_t err = cub::DeviceScan::ExclusiveSum(nullptr,
+                                                    bytes,
+                                                    static_cast<const T *>(nullptr),
+                                                    static_cast<T *>(nullptr),
+                                                    num_items);
+    *temp_bytes = bytes;
+    return err;
+}
+
+// Export one temp-size query and scan launch per supported element type.
+#define DEFINE_SCAN_EXCLUSIVE_SUM(suffix, Type)                                                              \
+    extern "C" cudaError_t scan_exclusive_sum_##suffix##_temp_size(size_t *temp_bytes, int64_t num_items) {  \
+        return scan_exclusive_sum_temp_size_impl<Type>(temp_bytes, num_items);                               \
+    }                                                                                                        \
+    extern "C" cudaError_t scan_exclusive_sum_##suffix(void *d_temp,                                         \
+                                                       size_t temp_bytes,                                    \
+                                                       const Type *d_in,                                     \
+                                                       Type *d_out,                                          \
+                                                       int64_t num_items,                                    \
+                                                       cudaStream_t stream) {                                \
+        return cub::DeviceScan::ExclusiveSum(d_temp, temp_bytes, d_in, d_out, num_items, stream);            \
+    }
+
+DEFINE_SCAN_EXCLUSIVE_SUM(i32, int32_t)
+DEFINE_SCAN_EXCLUSIVE_SUM(i64, int64_t)
diff --git a/vortex-cuda/cub/kernels/filter.h b/vortex-cuda/cub/kernels/filter.h
index 354b877dc17..c49dc62faed 100644
--- a/vortex-cuda/cub/kernels/filter.h
+++ b/vortex-cuda/cub/kernels/filter.h
@@ -81,6 +81,24 @@ FILTER_TYPE_TABLE(DECLARE_FILTER_BITMASK)
 
 #undef DECLARE_FILTER_BITMASK
 
+cudaError_t scan_exclusive_sum_i32_temp_size(size_t *temp_bytes, int64_t num_items);
+
+cudaError_t scan_exclusive_sum_i32(void *d_temp,
+                                   size_t temp_bytes,
+                                   const int32_t *d_in,
+                                   int32_t *d_out,
+                                   int64_t num_items,
+                                   cudaStream_t stream);
+
+cudaError_t scan_exclusive_sum_i64_temp_size(size_t *temp_bytes, int64_t num_items);
+
+cudaError_t scan_exclusive_sum_i64(void *d_temp,
+                                   size_t temp_bytes,
+                                   const int64_t *d_in,
+                                   int64_t *d_out,
+                                   int64_t num_items,
+                                   cudaStream_t stream);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/vortex-cuda/cub/src/lib.rs b/vortex-cuda/cub/src/lib.rs
index c0532576604..ae8e3b52b0f 100644
--- a/vortex-cuda/cub/src/lib.rs
+++ b/vortex-cuda/cub/src/lib.rs
@@ -23,6 +23,7 @@ pub mod sys;
 
 mod error;
 pub mod filter;
+pub mod scan;
 
 pub use error::CubError;
 
diff --git a/vortex-cuda/cub/src/scan.rs b/vortex-cuda/cub/src/scan.rs
new file mode 100644
index 00000000000..56b4e64b857
--- /dev/null
+++ b/vortex-cuda/cub/src/scan.rs
@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Rust wrappers around CUB DeviceScan operations used by CUDA kernels.
+
+use std::ffi::c_void;
+
+use crate::cub_library;
+use crate::error::CubError;
+use crate::error::check_cuda_error;
+pub use crate::sys::cudaStream_t;
+
+/// Get temporary storage size for CUB `DeviceScan::ExclusiveSum<i32>`.
+pub fn exclusive_sum_i32_temp_size(num_items: i64) -> Result<usize, CubError> {
+    let lib = cub_library()?;
+    let mut temp_bytes: usize = 0;
+    let err = unsafe { (lib.scan_exclusive_sum_i32_temp_size)(&raw mut temp_bytes, num_items) };
+    check_cuda_error(err, "scan_exclusive_sum_i32_temp_size")?;
+    Ok(temp_bytes)
+}
+
+/// Execute CUB `DeviceScan::ExclusiveSum<i32>`.
+///
+/// # Safety
+///
+/// All device pointers must be valid and properly sized:
+/// - `d_temp` must have at least `temp_bytes` bytes allocated.
+/// - `d_in` and `d_out` must have at least `num_items` `i32` values.
+pub unsafe fn exclusive_sum_i32(
+    d_temp: *mut c_void,
+    temp_bytes: usize,
+    d_in: *const i32,
+    d_out: *mut i32,
+    num_items: i64,
+    stream: cudaStream_t,
+) -> Result<(), CubError> {
+    let lib = cub_library()?;
+    let err =
+        unsafe { (lib.scan_exclusive_sum_i32)(d_temp, temp_bytes, d_in, d_out, num_items, stream) };
+    check_cuda_error(err, "scan_exclusive_sum_i32")
+}
+
+/// Get temporary storage size for CUB `DeviceScan::ExclusiveSum<i64>`.
+pub fn exclusive_sum_i64_temp_size(num_items: i64) -> Result<usize, CubError> {
+    let lib = cub_library()?;
+    let mut temp_bytes: usize = 0;
+    let err = unsafe { (lib.scan_exclusive_sum_i64_temp_size)(&raw mut temp_bytes, num_items) };
+    check_cuda_error(err, "scan_exclusive_sum_i64_temp_size")?;
+    Ok(temp_bytes)
+}
+
+/// Execute CUB `DeviceScan::ExclusiveSum<i64>`.
+///
+/// # Safety
+///
+/// All device pointers must be valid and properly sized:
+/// - `d_temp` must have at least `temp_bytes` bytes allocated.
+/// - `d_in` and `d_out` must have at least `num_items` `i64` values.
+pub unsafe fn exclusive_sum_i64(
+    d_temp: *mut c_void,
+    temp_bytes: usize,
+    d_in: *const i64,
+    d_out: *mut i64,
+    num_items: i64,
+    stream: cudaStream_t,
+) -> Result<(), CubError> {
+    let lib = cub_library()?;
+    let err =
+        unsafe { (lib.scan_exclusive_sum_i64)(d_temp, temp_bytes, d_in, d_out, num_items, stream) };
+    check_cuda_error(err, "scan_exclusive_sum_i64")
+}
diff --git a/vortex-cuda/ffi/Cargo.toml b/vortex-cuda/ffi/Cargo.toml
new file mode 100644
index 00000000000..a8ca51ad954
--- /dev/null
+++ b/vortex-cuda/ffi/Cargo.toml
@@ -0,0 +1,33 @@
+[package]
+name = "vortex-cuda-ffi"
+description = "Native C FFI bindings for Vortex CUDA interop"
+readme = "README.md"
+publish = false
+version = { workspace = true }
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+keywords = { workspace = true }
+include = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+categories = { workspace = true }
+
+[dependencies]
+arrow-schema = { workspace = true, features = ["ffi"] }
+futures = { workspace = true, features = ["executor"] }
+vortex = { workspace = true, features = ["object_store"] }
+vortex-cuda = { path = ".." }
+vortex-ffi = { path = "../../vortex-ffi" }
+
+[dev-dependencies]
+vortex-array = { workspace = true, features = ["_test-harness"] }
+vortex-cuda-macros = { workspace = true }
+
+[lib]
+name = "vortex_cuda_ffi"
+crate-type = ["rlib", "staticlib", "cdylib"]
+
+[lints]
+workspace = true
diff --git a/vortex-cuda/ffi/README.md b/vortex-cuda/ffi/README.md
new file mode 100644
index 00000000000..3c030095374
--- /dev/null
+++ b/vortex-cuda/ffi/README.md
@@ -0,0 +1,18 @@
+# vortex-cuda-ffi
+
+CUDA-specific C FFI helpers for cuDF interop.
+
+This crate keeps CUDA out of the base `vortex-ffi` crate. Its public C API exports a borrowed `vx_array` as an `ArrowSchema + ArrowDeviceArray` pair.
+
+It does not create cuDF objects itself. The caller passes the exported Arrow Device structs to cuDF and releases them after cuDF is done importing.
+
+Use this crate as the CUDA-enabled FFI artifact. Include both headers:
+
+```c
+#include "vortex.h"
+#include "vortex_cuda.h"
+```
+
+and link the CUDA FFI library (`vortex_cuda_ffi`). Do not pass Vortex handles between independently linked Rust FFI libraries.
+
+Use `vx_cuda_session_new` to initialize CUDA once and reuse it across exports.
diff --git a/vortex-cuda/ffi/cinclude/vortex_cuda.h b/vortex-cuda/ffi/cinclude/vortex_cuda.h
new file mode 100644
index 00000000000..ee0f0fb3ca3
--- /dev/null
+++ b/vortex-cuda/ffi/cinclude/vortex_cuda.h
@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+#pragma once
+
+#include <stdint.h>
+
+#include "vortex.h"
+
+/* Link against the CUDA-enabled FFI library that provides both the base Vortex FFI and these CUDA
+ * entry points. Do not pass Vortex handles between independently linked Rust FFI libraries. */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Definitions from the Arrow C Device data interface. Define USE_OWN_ARROW_DEVICE to skip them.
+ * https://arrow.apache.org/docs/format/CDeviceDataInterface.html */
+#if !defined(ARROW_C_DEVICE_DATA_INTERFACE) && !defined(USE_OWN_ARROW_DEVICE)
+#define ARROW_C_DEVICE_DATA_INTERFACE
+
+typedef int32_t ArrowDeviceType;
+#define ARROW_DEVICE_CPU          1
+#define ARROW_DEVICE_CUDA         2
+#define ARROW_DEVICE_CUDA_HOST    3
+#define ARROW_DEVICE_OPENCL       4
+#define ARROW_DEVICE_VULKAN       7
+#define ARROW_DEVICE_METAL        8
+#define ARROW_DEVICE_VPI          9
+#define ARROW_DEVICE_ROCM         10
+#define ARROW_DEVICE_ROCM_HOST    11
+#define ARROW_DEVICE_EXT_DEV      12
+#define ARROW_DEVICE_CUDA_MANAGED 13
+#define ARROW_DEVICE_ONEAPI       14
+#define ARROW_DEVICE_WEBGPU       15
+#define ARROW_DEVICE_HEXAGON      16
+
+struct ArrowDeviceArray {
+    struct ArrowArray array;
+    int64_t device_id;
+    ArrowDeviceType device_type;
+    void *sync_event;
+    int64_t reserved[3];
+};
+#endif
+
+/**
+ * Create a CUDA Vortex session.
+ *
+ * Repeated `vx_cuda_array_export_arrow_device` calls reuse this CUDA state. Returns an owned
+ * session handle, or NULL and an optional `vx_error` on failure.
+ */
+vx_session *vx_cuda_session_new(vx_error **error_out);
+
+/**
+ * Export a borrowed Vortex array for cuDF's Arrow Device import path.
+ *
+ * On success returns 0 and writes independently releasable `out_schema` and `out_array`; the caller
+ * passes them to cuDF and releases both via their embedded Arrow callbacks after import. On error
+ * returns 1 and, when `error_out` is non-NULL, writes a `vx_error` (free with `vx_error_free`).
+ *
+ * `out_array` is exported on `ARROW_DEVICE_CUDA`; struct arrays become table-shaped schemas,
+ * non-struct arrays a single column field.
+ *
+ * Export is stream-ordered; `out_array->sync_event` is valid until `out_array` is released.
+ */
+int vx_cuda_array_export_arrow_device(const vx_session *session,
+                                      const vx_array *array,
+                                      FFI_ArrowSchema *out_schema,
+                                      struct ArrowDeviceArray *out_array,
+                                      vx_error **error_out);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/vortex-cuda/ffi/src/lib.rs b/vortex-cuda/ffi/src/lib.rs
new file mode 100644
index 00000000000..2a74cb2666c
--- /dev/null
+++ b/vortex-cuda/ffi/src/lib.rs
@@ -0,0 +1,320 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![deny(missing_docs)]
+
+//! Native CUDA FFI helpers for cuDF interop.
+//!
+//! This crate keeps CUDA out of `vortex-ffi` and exports borrowed `vx_array` handles as the
+//! `ArrowSchema + ArrowDeviceArray` pair that callers pass to cuDF's Arrow Device import APIs.
+
+use std::os::raw::c_int;
+use std::ptr;
+
+use arrow_schema::ffi::FFI_ArrowSchema;
+use vortex::error::VortexResult;
+use vortex::error::vortex_ensure;
+use vortex::session::SessionExt;
+use vortex::session::VortexSession;
+use vortex_cuda::CudaSession;
+use vortex_cuda::arrow::ArrowDeviceArray;
+use vortex_cuda::arrow::DeviceArrayExt;
+use vortex_ffi::try_or;
+use vortex_ffi::vx_array;
+use vortex_ffi::vx_array_ref;
+use vortex_ffi::vx_error;
+use vortex_ffi::vx_session;
+use vortex_ffi::vx_session_new_with;
+use vortex_ffi::vx_session_ref;
+
+const VX_CUDA_OK: c_int = 0;
+const VX_CUDA_ERR: c_int = 1;
+
+fn session_with_cuda(session: &VortexSession) -> VortexResult<VortexSession> {
+    if session.get_opt::<CudaSession>().is_some() {
+        return Ok(session.clone());
+    }
+
+    Ok(session.clone().with_some(CudaSession::try_default()?))
+}
+
+/// Create a CUDA Vortex session.
+///
+/// Repeated [`vx_cuda_array_export_arrow_device`] calls reuse this CUDA state. Returns an owned
+/// session handle, or null and an optional `vx_error` on failure.
+///
+/// # Safety
+///
+/// If `error_out` is non-null, it must be valid for writing one error pointer.
+#[unsafe(no_mangle)]
+pub unsafe extern "C-unwind" fn vx_cuda_session_new(
+    error_out: *mut *mut vx_error,
+) -> *mut vx_session {
+    try_or(error_out, ptr::null_mut(), || {
+        let cuda_session = CudaSession::try_default()?;
+        Ok(vx_session_new_with(|session| {
+            session.with_some(cuda_session)
+        }))
+    })
+}
+
+/// Export a borrowed Vortex array for cuDF's Arrow Device import path.
+///
+/// On success returns `0` and writes independently releasable `out_schema` and `out_array`; the
+/// caller passes them to cuDF and releases both via their embedded Arrow callbacks after import. On
+/// error returns `1` and, when `error_out` is non-null, writes a `vx_error` (free with
+/// `vx_error_free`).
+///
+/// `out_array` is exported on `ARROW_DEVICE_CUDA`; struct arrays become table-shaped schemas,
+/// non-struct arrays a single column field.
+///
+/// Export is stream-ordered; `out_array->sync_event` is valid until `out_array` is released.
+///
+/// # Safety
+///
+/// `session` and `array` must be valid borrowed handles created by `vortex-ffi`. `out_schema`
+/// and `out_array` must be valid writable pointers. If `error_out` is non-null, it must be valid
+/// for writing one error pointer.
+#[unsafe(no_mangle)]
+pub unsafe extern "C-unwind" fn vx_cuda_array_export_arrow_device(
+    session: *const vx_session,
+    array: *const vx_array,
+    out_schema: *mut FFI_ArrowSchema,
+    out_array: *mut ArrowDeviceArray,
+    error_out: *mut *mut vx_error,
+) -> c_int {
+    try_or(error_out, VX_CUDA_ERR, || {
+        vortex_ensure!(!out_schema.is_null(), "null ArrowSchema output");
+        vortex_ensure!(!out_array.is_null(), "null ArrowDeviceArray output");
+
+        let session = session_with_cuda(unsafe { vx_session_ref(session) }?)?;
+        let array = unsafe { vx_array_ref(array) }?.clone();
+        let mut ctx = CudaSession::create_execution_ctx(&session)?;
+        let exported =
+            futures::executor::block_on(array.export_device_array_with_schema(&mut ctx))?;
+
+        unsafe {
+            ptr::write(out_schema, exported.schema);
+            ptr::write(out_array, exported.array);
+        }
+        Ok(VX_CUDA_OK)
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use std::ptr;
+    use std::sync::Arc;
+
+    use arrow_schema::Field;
+    use arrow_schema::Schema;
+    use vortex::VortexSessionDefault;
+    use vortex::array::ArrayRef;
+    use vortex::array::IntoArray;
+    use vortex::array::arrays::PrimitiveArray;
+    use vortex::array::arrays::StructArray;
+    use vortex::array::validity::Validity;
+    use vortex::error::VortexResult;
+    use vortex_cuda::arrow::ARROW_DEVICE_CUDA;
+    use vortex_cuda_macros::cuda_not_available;
+    use vortex_cuda_macros::test as cuda_test;
+
+    use super::*;
+
+    fn test_session(session: VortexSession) -> *mut vx_session {
+        Box::into_raw(Box::new(session)).cast::<vx_session>()
+    }
+
+    unsafe fn free_test_session(session: *mut vx_session) {
+        unsafe { drop(Box::from_raw(session.cast::<VortexSession>())) };
+    }
+
+    fn test_array(array: impl IntoArray) -> *const vx_array {
+        Arc::into_raw(Arc::new(array.into_array())).cast::<vx_array>()
+    }
+
+    unsafe fn free_test_array(array: *const vx_array) {
+        unsafe { Arc::decrement_strong_count(array.cast::<ArrayRef>()) };
+    }
+
+    unsafe fn release_schema(schema: &mut FFI_ArrowSchema) {
+        unsafe {
+            if let Some(release) = schema.release {
+                release(schema);
+            }
+        }
+    }
+
+    unsafe fn release_device_array(array: &mut ArrowDeviceArray) {
+        unsafe {
+            if let Some(release) = array.array.release {
+                release(&raw mut array.array);
+            }
+        }
+    }
+
+    fn empty_device_array() -> ArrowDeviceArray {
+        ArrowDeviceArray {
+            array: vortex_cuda::arrow::ArrowArray::empty(),
+            device_id: 0,
+            device_type: 0,
+            sync_event: ptr::null_mut(),
+            reserved: [0; 3],
+        }
+    }
+
+    #[cuda_test]
+    fn test_export_primitive_arrow_device() {
+        let mut error = ptr::null_mut();
+        let session = test_session(VortexSession::default());
+        let array = test_array(PrimitiveArray::from_iter(0u32..5));
+        let mut schema = FFI_ArrowSchema::empty();
+        let mut device_array = empty_device_array();
+
+        let status = unsafe {
+            vx_cuda_array_export_arrow_device(
+                session,
+                array,
+                &raw mut schema,
+                &raw mut device_array,
+                &raw mut error,
+            )
+        };
+        assert_eq!(status, VX_CUDA_OK);
+        assert!(error.is_null());
+
+        let field = Field::try_from(&schema).expect("schema should be a field");
+        assert_eq!(field.name(), "");
+        assert_eq!(device_array.array.length, 5);
+        assert_eq!(device_array.array.n_buffers, 2);
+        assert_eq!(device_array.device_type, ARROW_DEVICE_CUDA);
+        assert_eq!(device_array.reserved, [0; 3]);
+        assert!(device_array.array.release.is_some());
+
+        unsafe {
+            release_device_array(&mut device_array);
+            release_schema(&mut schema);
+            free_test_array(array);
+            free_test_session(session);
+        }
+    }
+
+    #[cuda_test]
+    fn test_export_struct_arrow_device_table() -> VortexResult<()> {
+        let mut error = ptr::null_mut();
+        let session = test_session(VortexSession::default());
+        let array = test_array(StructArray::try_new(
+            ["ids", "values"].into(),
+            vec![
+                PrimitiveArray::from_iter(0u32..3).into_array(),
+                PrimitiveArray::from_iter([10i64, 20, 30]).into_array(),
+            ],
+            3,
+            Validity::NonNullable,
+        )?);
+
+        let mut schema = FFI_ArrowSchema::empty();
+        let mut device_array = empty_device_array();
+
+        let status = unsafe {
+            vx_cuda_array_export_arrow_device(
+                session,
+                array,
+                &raw mut schema,
+                &raw mut device_array,
+                &raw mut error,
+            )
+        };
+        assert_eq!(status, VX_CUDA_OK);
+        assert!(error.is_null());
+
+        let arrow_schema = Schema::try_from(&schema)?;
+        assert_eq!(arrow_schema.fields().len(), 2);
+        assert_eq!(arrow_schema.field(0).name(), "ids");
+        assert_eq!(arrow_schema.field(1).name(), "values");
+
+        assert_eq!(device_array.device_type, ARROW_DEVICE_CUDA);
+        assert_eq!(device_array.reserved, [0; 3]);
+        assert_eq!(device_array.array.length, 3);
+        assert_eq!(device_array.array.n_buffers, 1);
+        assert_eq!(device_array.array.n_children, 2);
+        assert!(device_array.array.release.is_some());
+
+        let children = unsafe { std::slice::from_raw_parts(device_array.array.children, 2) };
+        for child in children {
+            let child = unsafe { &**child };
+            assert_eq!(child.length, 3);
+            assert_eq!(child.n_buffers, 2);
+            assert!(child.release.is_some());
+        }
+
+        unsafe {
+            release_device_array(&mut device_array);
+            assert!(device_array.array.release.is_none());
+            release_schema(&mut schema);
+            free_test_array(array);
+            free_test_session(session);
+        }
+        Ok(())
+    }
+
+    #[cuda_test]
+    fn test_cuda_session_new_export() {
+        let mut error = ptr::null_mut();
+        let session = unsafe { vx_cuda_session_new(&raw mut error) };
+        assert!(error.is_null());
+        assert!(!session.is_null());
+
+        let array = test_array(PrimitiveArray::from_iter(0u32..5));
+        let mut schema = FFI_ArrowSchema::empty();
+        let mut device_array = empty_device_array();
+
+        let status = unsafe {
+            vx_cuda_array_export_arrow_device(
+                session,
+                array,
+                &raw mut schema,
+                &raw mut device_array,
+                &raw mut error,
+            )
+        };
+        assert_eq!(status, VX_CUDA_OK);
+        assert!(error.is_null());
+        assert_eq!(device_array.array.length, 5);
+        assert_eq!(device_array.device_type, ARROW_DEVICE_CUDA);
+
+        unsafe {
+            release_device_array(&mut device_array);
+            release_schema(&mut schema);
+            free_test_array(array);
+            vortex_ffi::vx_session_free(session);
+        }
+    }
+
+    #[cuda_not_available]
+    #[test]
+    fn test_export_reports_cuda_initialization_error() {
+        let session = test_session(VortexSession::default());
+        let array = test_array(PrimitiveArray::from_iter(0u32..5));
+        let mut schema = FFI_ArrowSchema::empty();
+        let mut device_array = empty_device_array();
+        let mut error = ptr::null_mut();
+
+        let status = unsafe {
+            vx_cuda_array_export_arrow_device(
+                session,
+                array,
+                &raw mut schema,
+                &raw mut device_array,
+                &raw mut error,
+            )
+        };
+        assert_eq!(status, VX_CUDA_ERR);
+        assert!(!error.is_null());
+        unsafe {
+            vortex_ffi::vx_error_free(error);
+            free_test_array(array);
+            free_test_session(session);
+        }
+    }
+}
diff --git a/vortex-cuda/kernels/src/arrow_binary.cu b/vortex-cuda/kernels/src/arrow_binary.cu
new file mode 100644
index 00000000000..836d6d1ce29
--- /dev/null
+++ b/vortex-cuda/kernels/src/arrow_binary.cu
@@ -0,0 +1,222 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#include "config.cuh"
+
+#include <limits.h>
+#include <stdint.h>
+
+namespace {
+
+constexpr uint32_t MAX_INLINED_SIZE = 12;
+
+struct BinaryView {
+    uint32_t size;
+    uint8_t inline_data[MAX_INLINED_SIZE];
+};
+
+struct BinaryViewRef {
+    uint32_t size;
+    uint8_t prefix[4];
+    uint32_t buffer_index;
+    uint32_t offset;
+};
+
+// Return whether a row is valid in a little-endian Arrow/Vortex bitmap, treating a missing (null)
+// validity bitmap as all-valid.
+__device__ bool is_valid(const uint8_t *const validity, uint64_t idx) {
+    return validity == nullptr || ((validity[idx / 8] >> (idx % 8)) & 1);
+}
+
+// Initialize scan input from BinaryView sizes. Null rows contribute zero bytes so the gather kernel
+// never needs to read their view payload.
+//
+// Threads stride by blockDim within the block's element range so warp accesses to views and scan
+// stay coalesced.
+__device__ void init_scan_device(const BinaryView *const __restrict views,
+                                 const uint8_t *const __restrict validity,
+                                 const uint64_t *const __restrict data_buffer_lens,
+                                 int32_t *const __restrict scan,
+                                 uint32_t *const status,
+                                 uint64_t data_buffer_count,
+                                 uint64_t len) {
+    const uint64_t scan_len = len + 1;
+    const uint64_t elements_per_block = blockDim.x * ELEMENTS_PER_THREAD;
+    const uint64_t block_start = blockIdx.x * elements_per_block;
+    const uint64_t block_stop = min(block_start + elements_per_block, scan_len);
+
+    for (uint64_t idx = block_start + threadIdx.x; idx < block_stop; idx += blockDim.x) {
+        if (idx >= len || !is_valid(validity, idx)) {
+            scan[idx] = 0;
+            continue;
+        }
+
+        const BinaryView view = views[idx];
+        const uint32_t size = view.size;
+        if (size > static_cast<uint32_t>(INT32_MAX)) {
+            scan[idx] = 0;
+            atomicMax(status, 2u);
+            continue;
+        }
+
+        if (size > MAX_INLINED_SIZE) {
+            const BinaryViewRef *const view_ref = reinterpret_cast<const BinaryViewRef *>(&view);
+            const uint64_t buffer_index = static_cast<uint64_t>(view_ref->buffer_index);
+            const uint64_t offset = static_cast<uint64_t>(view_ref->offset);
+            // Both addends are u32 widened to u64, so the end position cannot wrap.
+            const uint64_t end = offset + static_cast<uint64_t>(size);
+            if (buffer_index >= data_buffer_count || end > data_buffer_lens[buffer_index]) {
+                scan[idx] = 0;
+                atomicMax(status, 1u);
+                continue;
+            }
+        }
+
+        scan[idx] = static_cast<int32_t>(size);
+    }
+}
+
+// Detect i32 overflow of the CUB exclusive-sum offsets by checking signs. init_scan rejects
+// per-row sizes above i32::MAX, so consecutive true prefix sums differ by less than 2^31 and the
+// first overflowing prefix lands in [2^31, 2^32), which wraps to a negative offset in the scan
+// output. No negative offset therefore proves no prefix overflowed.
+__device__ void
+validate_offsets_device(const int32_t *const __restrict offsets, uint32_t *const status, uint64_t scan_len) {
+    const uint64_t elements_per_block = blockDim.x * ELEMENTS_PER_THREAD;
+    const uint64_t block_start = blockIdx.x * elements_per_block;
+    const uint64_t block_stop = min(block_start + elements_per_block, scan_len);
+
+    for (uint64_t idx = block_start + threadIdx.x; idx < block_stop; idx += blockDim.x) {
+        if (offsets[idx] < 0) {
+            atomicMax(status, 2u);
+        }
+    }
+}
+
+__device__ uint64_t upper_bound_offsets(const int32_t *const offsets, uint64_t len, uint64_t value) {
+    uint64_t first = 0;
+    while (len > 0) {
+        const uint64_t half = len / 2;
+        const uint64_t mid = first + half;
+        if (static_cast<uint64_t>(offsets[mid]) <= value) {
+            first = mid + 1;
+            len -= half + 1;
+        } else {
+            len = half;
+        }
+    }
+    return first;
+}
+
+// Resolve the payload pointer for one view, pointing inline views at their global view bytes.
+__device__ const uint8_t *
+input_ptr(const BinaryView *const views, uint64_t row, const uint64_t *const data_buffer_ptrs) {
+    const BinaryView *const view = views + row;
+    if (view->size <= MAX_INLINED_SIZE) {
+        return view->inline_data;
+    }
+
+    const BinaryViewRef *const view_ref = reinterpret_cast<const BinaryViewRef *>(view);
+    return reinterpret_cast<const uint8_t *>(data_buffer_ptrs[view_ref->buffer_index]) + view_ref->offset;
+}
+
+// Copy BinaryView payload bytes into one contiguous Arrow Binary values buffer.
+//
+// Each thread owns a contiguous ELEMENTS_PER_THREAD output byte range, so the row lookup runs once
+// per range and then advances sequentially. Byte stores from such strided ranges waste almost the
+// whole memory transaction, so threads stage 16 output bytes in registers and write them with one
+// vector store. Full chunks start at a multiple of ELEMENTS_PER_THREAD, keeping the stores aligned.
+__device__ void gather_device(const BinaryView *const __restrict views,
+                              const uint64_t *const __restrict data_buffer_ptrs,
+                              const int32_t *const __restrict offsets,
+                              uint8_t *const __restrict output,
+                              uint64_t len,
+                              uint64_t total_bytes) {
+    const uint64_t worker = blockIdx.x * blockDim.x + threadIdx.x;
+    const uint64_t start = start_elem(worker, total_bytes);
+    const uint64_t stop = stop_elem(worker, total_bytes);
+    if (start == stop) {
+        return;
+    }
+
+    uint64_t row = upper_bound_offsets(offsets, len + 1, start) - 1;
+    uint64_t row_start = static_cast<uint64_t>(offsets[row]);
+    uint64_t row_end = static_cast<uint64_t>(offsets[row + 1]);
+    const uint8_t *input = input_ptr(views, row, data_buffer_ptrs);
+
+    const auto next_byte = [&](uint64_t byte_idx) -> uint8_t {
+        while (byte_idx >= row_end) {
+            row++;
+            row_start = static_cast<uint64_t>(offsets[row]);
+            row_end = static_cast<uint64_t>(offsets[row + 1]);
+            input = input_ptr(views, row, data_buffer_ptrs);
+        }
+        return input[byte_idx - row_start];
+    };
+
+    uint64_t byte_idx = start;
+    for (; byte_idx + 16 <= stop; byte_idx += 16) {
+        while (byte_idx >= row_end) {
+            row++;
+            row_start = static_cast<uint64_t>(offsets[row]);
+            row_end = static_cast<uint64_t>(offsets[row + 1]);
+            input = input_ptr(views, row, data_buffer_ptrs);
+        }
+
+        // Fast path: the group sits inside one row and the source allows word loads.
+        const uint8_t *const src = input + (byte_idx - row_start);
+        if (byte_idx + 16 <= row_end && (reinterpret_cast<uintptr_t>(src) & 3) == 0) {
+            const uint32_t *const src_words = reinterpret_cast<const uint32_t *>(src);
+            *reinterpret_cast<uint4 *>(output + byte_idx) =
+                make_uint4(src_words[0], src_words[1], src_words[2], src_words[3]);
+            continue;
+        }
+
+        uint32_t words[4];
+#pragma unroll
+        for (uint32_t word = 0; word < 4; word++) {
+            uint32_t value = 0;
+#pragma unroll
+            for (uint32_t byte = 0; byte < 4; byte++) {
+                const uint64_t lane = byte_idx + word * 4 + byte;
+                value |= static_cast<uint32_t>(next_byte(lane)) << (byte * 8);
+            }
+            words[word] = value;
+        }
+        *reinterpret_cast<uint4 *>(output + byte_idx) = make_uint4(words[0], words[1], words[2], words[3]);
+    }
+
+    for (; byte_idx < stop; byte_idx++) {
+        output[byte_idx] = next_byte(byte_idx);
+    }
+}
+
+} // namespace
+
+// Fill the CUB scan input with per-row binary lengths plus a final zero sentinel. A null validity
+// pointer marks an all-valid array.
+extern "C" __global__ void arrow_binary_init_scan(const BinaryView *const views,
+                                                  const uint8_t *const validity,
+                                                  const uint64_t *const data_buffer_lens,
+                                                  int32_t *const scan,
+                                                  uint32_t *const status,
+                                                  uint64_t data_buffer_count,
+                                                  uint64_t len) {
+    init_scan_device(views, validity, data_buffer_lens, scan, status, data_buffer_count, len);
+}
+
+// Check that the scanned Arrow Binary offsets never overflowed the i32 range.
+extern "C" __global__ void
+arrow_binary_validate_offsets(const int32_t *const offsets, uint32_t *const status, uint64_t scan_len) {
+    validate_offsets_device(offsets, status, scan_len);
+}
+
+// Gather inline and referenced BinaryView payloads into Arrow Binary's contiguous values buffer.
+extern "C" __global__ void arrow_binary_gather(const BinaryView *const views,
+                                               const uint64_t *const data_buffer_ptrs,
+                                               const int32_t *const offsets,
+                                               uint8_t *const output,
+                                               uint64_t len,
+                                               uint64_t total_bytes) {
+    gather_device(views, data_buffer_ptrs, offsets, output, len, total_bytes);
+}
diff --git a/vortex-cuda/kernels/src/arrow_validity.cu b/vortex-cuda/kernels/src/arrow_validity.cu
new file mode 100644
index 00000000000..906054c86ee
--- /dev/null
+++ b/vortex-cuda/kernels/src/arrow_validity.cu
@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#include "config.cuh"
+
+#include <stdint.h>
+
+namespace {
+
+// Load the `word_idx`-th little-endian u64 of `input`, treating bytes outside
+// `[0, input_bytes)` as zero. `input` must be 8-byte aligned.
+__device__ uint64_t load_input_word(const uint8_t *const input, int64_t word_idx, uint64_t input_bytes) {
+    if (word_idx < 0) {
+        return 0;
+    }
+    const uint64_t byte_idx = static_cast<uint64_t>(word_idx) * sizeof(uint64_t);
+    if (byte_idx >= input_bytes) {
+        return 0;
+    }
+    if (byte_idx + sizeof(uint64_t) <= input_bytes) {
+        return reinterpret_cast<const uint64_t *>(input)[word_idx];
+    }
+    // Trailing partial word: assemble byte-by-byte to avoid reading past the buffer.
+    uint64_t word = 0;
+    for (uint64_t i = byte_idx; i < input_bytes; i++) {
+        word |= static_cast<uint64_t>(input[i]) << ((i - byte_idx) * 8);
+    }
+    return word;
+}
+
+// Build one 64-bit word of the Arrow validity bitmap.
+//
+// Output bit `b` for `b` in `[arrow_offset, validity_bits)` equals input bit `b + shift`;
+// all other bits are zero. Two adjacent input words are funnel-shifted to align the input
+// bits with the output word, then the leading/trailing edges are masked.
+__device__ uint64_t repack_word(const uint8_t *const input,
+                                uint64_t word_idx,
+                                int64_t shift,
+                                uint64_t arrow_offset,
+                                uint64_t validity_bits,
+                                uint64_t input_bytes) {
+    const uint64_t word_start = word_idx * 64;
+
+    // Bits before Arrow's array offset are padding from the consumer's point of view.
+    // Tail bits beyond len + offset stay zero so word-at-a-time mask readers are safe.
+    uint64_t mask = ~uint64_t {0};
+    if (word_start < arrow_offset) {
+        const uint64_t lead = arrow_offset - word_start;
+        mask = lead >= 64 ? 0 : mask << lead;
+    }
+    const uint64_t remaining = validity_bits - word_start;
+    if (remaining < 64) {
+        mask &= (uint64_t {1} << remaining) - 1;
+    }
+    if (mask == 0) {
+        return 0;
+    }
+
+    // `>> 6` floors also for negative bit positions, unlike `/ 64` which truncates toward zero.
+    const int64_t input_bit = static_cast<int64_t>(word_start) + shift;
+    const int64_t input_word = input_bit >> 6;
+    const uint32_t bit = static_cast<uint32_t>(input_bit & 63);
+
+    const uint64_t lo = load_input_word(input, input_word, input_bytes);
+    if (bit == 0) {
+        return lo & mask;
+    }
+    const uint64_t hi = load_input_word(input, input_word + 1, input_bytes);
+    return ((lo >> bit) | (hi << (64 - bit))) & mask;
+}
+
+// Rebuild a possibly bit-offset Vortex validity bitmap into an Arrow-compatible bitmap.
+//
+// `input_offset` is the bit offset into `input`; `arrow_offset` is the logical Arrow array offset
+// to preserve in the output. Bits outside `[arrow_offset, arrow_offset + len)` are left unset.
+// The output allocation must hold `ceil((len + arrow_offset) / 64)` full 64-bit words; every
+// word is written, so no zero-initialization of the output is required.
+__device__ void arrow_validity_repack_device(const uint8_t *const input,
+                                             uint64_t *const output,
+                                             uint64_t len,
+                                             uint64_t input_offset,
+                                             uint64_t arrow_offset,
+                                             uint64_t input_bytes) {
+    // One worker owns a contiguous range of output words. Each word is rebuilt locally so
+    // there are no cross-thread bit writes or atomics.
+    const uint64_t worker = blockIdx.x * blockDim.x + threadIdx.x;
+    const uint64_t validity_bits = len + arrow_offset;
+    const uint64_t output_words = (validity_bits + 63) / 64;
+    const uint64_t stride = static_cast<uint64_t>(gridDim.x) * blockDim.x;
+
+    // Translate Arrow-visible output bits back to source bitmap bits. The source bitmap may
+    // start at any bit offset, while Arrow's buffer pointer is byte-addressed.
+    const int64_t shift = static_cast<int64_t>(input_offset) - static_cast<int64_t>(arrow_offset);
+
+    for (uint64_t word_idx = worker; word_idx < output_words; word_idx += stride) {
+        output[word_idx] = repack_word(input, word_idx, shift, arrow_offset, validity_bits, input_bytes);
+    }
+}
+
+} // namespace
+
+// CUDA entry point for validity bitmap repacking used by Arrow Device export.
+extern "C" __global__ void arrow_validity_repack(const uint8_t *const input,
+                                                 uint64_t *const output,
+                                                 uint64_t len,
+                                                 uint64_t input_offset,
+                                                 uint64_t arrow_offset,
+                                                 uint64_t input_bytes) {
+    arrow_validity_repack_device(input, output, len, input_offset, arrow_offset, input_bytes);
+}
diff --git a/vortex-cuda/kernels/src/decimal_cast.cu b/vortex-cuda/kernels/src/decimal_cast.cu
new file mode 100644
index 00000000000..45c8c75e2a0
--- /dev/null
+++ b/vortex-cuda/kernels/src/decimal_cast.cu
@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#include "config.cuh"
+#include "types.cuh"
+#include <stdint.h>
+#include <type_traits>
+
+// Arrow decimal schemas fix the physical values buffer width:
+//   - Decimal32: 4 bytes per value.
+//   - Decimal64: 8 bytes per value.
+//   - Decimal128: 16 bytes per value.
+//   - Decimal256: 32 bytes per value.
+//
+// Vortex storage width can differ, so export casts to the schema-implied width.
+// Rust-side export rejects narrowing casts because detecting overflow on-device
+// would require synchronizing an overflow flag back to the host.
+
+// Low 64-bit conversion for Decimal32/64 outputs.
+template <typename Input>
+__device__ __forceinline__ int64_t decimal_to_i64(Input value) {
+    if constexpr (std::is_same_v<Input, int128_t>) {
+        return value.lo;
+    } else if constexpr (std::is_same_v<Input, int256_t>) {
+        return value.parts[0];
+    } else {
+        return static_cast<int64_t>(value);
+    }
+}
+
+// 128-bit conversion for Decimal128 outputs.
+template <typename Input>
+__device__ __forceinline__ int128_t decimal_to_i128(Input value) {
+    if constexpr (std::is_same_v<Input, int128_t>) {
+        return value;
+    } else if constexpr (std::is_same_v<Input, int256_t>) {
+        return int128_t {value.parts[0], value.parts[1]};
+    } else {
+        const int64_t lo = static_cast<int64_t>(value);
+        const int64_t hi = value < 0 ? -1 : 0;
+        return int128_t {lo, hi};
+    }
+}
+
+// Convert one value to the Arrow schema's physical width.
+template <typename Output, typename Input>
+__device__ __forceinline__ Output decimal_cast_value(Input value) {
+    if constexpr (std::is_same_v<Output, int32_t>) {
+        return static_cast<int32_t>(decimal_to_i64(value));
+    } else if constexpr (std::is_same_v<Output, int64_t>) {
+        return decimal_to_i64(value);
+    } else if constexpr (std::is_same_v<Output, int128_t>) {
+        return decimal_to_i128(value);
+    } else {
+        static_assert(std::is_same_v<Output, int256_t>);
+        if constexpr (std::is_same_v<Input, int256_t>) {
+            return value;
+        } else {
+            const int128_t value128 = decimal_to_i128(value);
+            const int64_t sign = value128.hi < 0 ? -1 : 0;
+            return int256_t {{value128.lo, value128.hi, sign, sign}};
+        }
+    }
+}
+
+// Cast a contiguous values buffer to the Arrow schema's physical width.
+template <typename Input, typename Output>
+__device__ void
+decimal_cast_device(const Input *__restrict input, Output *__restrict output, uint64_t array_len) {
+    const uint64_t elements_per_block = blockDim.x * ELEMENTS_PER_THREAD;
+    const uint64_t block_start = blockIdx.x * elements_per_block;
+    const uint64_t block_stop = min(block_start + elements_per_block, array_len);
+
+    for (uint64_t idx = block_start + threadIdx.x; idx < block_stop; idx += blockDim.x) {
+        output[idx] = decimal_cast_value<Output>(input[idx]);
+    }
+}
+
+// Generate Decimal32/64/128/256 cast kernels for one input storage type.
+#define GENERATE_DECIMAL_CAST_KERNELS(input_suffix, InputType)                                               \
+    extern "C" __global__ void decimal_cast_##input_suffix##_i32(const InputType *__restrict input,          \
+                                                                 int32_t *__restrict output,                 \
+                                                                 uint64_t array_len) {                       \
+        decimal_cast_device(input, output, array_len);                                                       \
+    }                                                                                                        \
+    extern "C" __global__ void decimal_cast_##input_suffix##_i64(const InputType *__restrict input,          \
+                                                                 int64_t *__restrict output,                 \
+                                                                 uint64_t array_len) {                       \
+        decimal_cast_device(input, output, array_len);                                                       \
+    }                                                                                                        \
+    extern "C" __global__ void decimal_cast_##input_suffix##_i128(const InputType *__restrict input,         \
+                                                                  int128_t *__restrict output,               \
+                                                                  uint64_t array_len) {                      \
+        decimal_cast_device(input, output, array_len);                                                       \
+    }                                                                                                        \
+    extern "C" __global__ void decimal_cast_##input_suffix##_i256(const InputType *__restrict input,         \
+                                                                  int256_t *__restrict output,               \
+                                                                  uint64_t array_len) {                      \
+        decimal_cast_device(input, output, array_len);                                                       \
+    }
+
+FOR_EACH_SIGNED_INT(GENERATE_DECIMAL_CAST_KERNELS)
+FOR_EACH_LARGE_DECIMAL(GENERATE_DECIMAL_CAST_KERNELS)
diff --git a/vortex-cuda/kernels/src/dynamic_dispatch.cu b/vortex-cuda/kernels/src/dynamic_dispatch.cu
index 2f9fbfcada0..fa19b47fe1a 100644
--- a/vortex-cuda/kernels/src/dynamic_dispatch.cu
+++ b/vortex-cuda/kernels/src/dynamic_dispatch.cu
@@ -199,6 +199,9 @@ scalar_op(T *values, const struct ScalarOp &op, char *__restrict smem, uint64_t
         }
         break;
     }
+    case ScalarOp::CAST:
+        // Values are casted as part of LOAD as defined by the dispatch plan.
+        break;
     default:
         __builtin_unreachable();
     }
diff --git a/vortex-cuda/kernels/src/dynamic_dispatch.h b/vortex-cuda/kernels/src/dynamic_dispatch.h
index c4dbe55c9f3..e3b1d0f8df3 100644
--- a/vortex-cuda/kernels/src/dynamic_dispatch.h
+++ b/vortex-cuda/kernels/src/dynamic_dispatch.h
@@ -173,6 +173,7 @@ struct SourceOp {
 /// change it:
 ///   - ALP: encoded int → float (e.g. i32 → f32, i64 → f64)
 ///   - DICT: codes type → values type (e.g. u8 → u32)
+///   - CAST: current type → requested output type
 ///
 /// The plan builder uses `output_ptype` to determine the element width
 /// for shared memory allocation and to propagate type information
@@ -200,10 +201,10 @@ union ScalarParams {
 };
 
 struct ScalarOp {
-    enum ScalarOpCode { FOR, ZIGZAG, ALP, DICT } op_code;
-    /// The PType this op produces. For type-preserving ops (FOR, ZIGZAG)
-    /// this equals the input PType. For type-changing ops (ALP, DICT) this
-    /// is the new output PType.
+    enum ScalarOpCode { FOR, ZIGZAG, ALP, DICT, CAST } op_code;
+    /// The PType this op produces. For type-preserving ops (FOR, ZIGZAG) this
+    /// equals the input PType. For type-changing ops (ALP, DICT, CAST) this is
+    /// the new output PType.
     enum PTypeTag output_ptype;
     union ScalarParams params;
 };
diff --git a/vortex-cuda/kernels/src/list_view.cu b/vortex-cuda/kernels/src/list_view.cu
new file mode 100644
index 00000000000..27f1a7d98e5
--- /dev/null
+++ b/vortex-cuda/kernels/src/list_view.cu
@@ -0,0 +1,248 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#include "config.cuh"
+
+#include <stdint.h>
+#include <type_traits>
+
+namespace {
+
+template <typename T>
+__device__ bool non_negative_to_u64(T value, uint64_t *out) {
+    if constexpr (std::is_signed_v<T>) {
+        if (value < 0) {
+            return false;
+        }
+    }
+
+    *out = static_cast<uint64_t>(value);
+    return true;
+}
+
+__device__ bool checked_add_u64(uint64_t lhs, uint64_t rhs, uint64_t *out) {
+    if (rhs > UINT64_MAX - lhs) {
+        return false;
+    }
+
+    *out = lhs + rhs;
+    return true;
+}
+
+// Assumes `ListViewArray` construction invariants for basic metadata validity. This kernel only
+// decides whether the views are already contiguous Arrow `List` offsets and fit cuDF's i32 limit.
+template <typename OffsetT, typename SizeT>
+__device__ void list_view_offsets_device(const OffsetT *const offsets,
+                                         const SizeT *const sizes,
+                                         int32_t *const output,
+                                         uint32_t *const status,
+                                         uint64_t list_len) {
+    const uint64_t elements_per_block = blockDim.x * ELEMENTS_PER_THREAD;
+    const uint64_t block_start = blockIdx.x * elements_per_block;
+    const uint64_t block_stop = min(block_start + elements_per_block, list_len);
+
+    for (uint64_t idx = block_start + threadIdx.x; idx < block_stop; idx += blockDim.x) {
+        const uint64_t offset = static_cast<uint64_t>(offsets[idx]);
+        const uint64_t end = offset + static_cast<uint64_t>(sizes[idx]);
+        output[idx] = static_cast<int32_t>(offset);
+
+        if (end < offset || end > static_cast<uint64_t>(INT32_MAX)) {
+            atomicMax(status, 2u);
+        }
+        if (idx == 0 && offset != 0) {
+            atomicMax(status, 1u);
+        }
+
+        if (idx + 1 == list_len) {
+            output[list_len] = static_cast<int32_t>(end);
+        } else if (static_cast<uint64_t>(offsets[idx + 1]) != end) {
+            atomicMax(status, 1u);
+        }
+    }
+}
+
+template <typename SizeT>
+__device__ void list_view_rebuild_init_scan_device(const SizeT *const sizes,
+                                                   int32_t *const scan,
+                                                   uint32_t *const status,
+                                                   uint64_t list_len,
+                                                   uint64_t scan_len) {
+    const uint64_t elements_per_block = blockDim.x * ELEMENTS_PER_THREAD;
+    const uint64_t block_start = blockIdx.x * elements_per_block;
+    const uint64_t block_stop = min(block_start + elements_per_block, scan_len);
+
+    for (uint64_t idx = block_start + threadIdx.x; idx < block_stop; idx += blockDim.x) {
+        if (idx >= list_len) {
+            scan[idx] = 0;
+            continue;
+        }
+
+        uint64_t size = 0;
+        if (!non_negative_to_u64(sizes[idx], &size)) {
+            atomicMax(status, 1u);
+            scan[idx] = 0;
+        } else if (size > static_cast<uint64_t>(INT32_MAX)) {
+            atomicMax(status, 2u);
+            scan[idx] = 0;
+        } else {
+            scan[idx] = static_cast<int32_t>(size);
+        }
+    }
+}
+
+template <typename SizeT>
+__device__ void list_view_rebuild_validate_offsets_device(const SizeT *const sizes,
+                                                          const int32_t *const output_offsets,
+                                                          uint32_t *const status,
+                                                          uint64_t list_len) {
+    const uint64_t elements_per_block = blockDim.x * ELEMENTS_PER_THREAD;
+    const uint64_t block_start = blockIdx.x * elements_per_block;
+    const uint64_t block_stop = min(block_start + elements_per_block, list_len);
+
+    for (uint64_t idx = block_start + threadIdx.x; idx < block_stop; idx += blockDim.x) {
+        const int32_t offset = output_offsets[idx];
+        const int32_t next_offset = output_offsets[idx + 1];
+        if (offset < 0 || next_offset < 0) {
+            atomicMax(status, 2u);
+            continue;
+        }
+
+        uint64_t size = 0;
+        if (!non_negative_to_u64(sizes[idx], &size)) {
+            atomicMax(status, 1u);
+            continue;
+        }
+
+        const int64_t expected_next = static_cast<int64_t>(offset) + static_cast<int64_t>(size);
+        if (size > static_cast<uint64_t>(INT32_MAX) || expected_next != static_cast<int64_t>(next_offset)) {
+            atomicMax(status, 2u);
+        }
+    }
+}
+
+template <typename OffsetT, typename SizeT>
+__device__ void list_view_rebuild_primitive_device(const OffsetT *const offsets,
+                                                   const SizeT *const sizes,
+                                                   const int32_t *const output_offsets,
+                                                   const uint8_t *const input_values,
+                                                   uint8_t *const output_values,
+                                                   uint32_t *const status,
+                                                   uint64_t list_len,
+                                                   uint64_t elements_len,
+                                                   uint64_t value_width) {
+    const uint64_t worker = blockIdx.x * blockDim.x + threadIdx.x;
+    const uint64_t startElem = start_elem(worker, list_len);
+    const uint64_t stopElem = stop_elem(worker, list_len);
+
+    for (uint64_t list_idx = startElem; list_idx < stopElem; list_idx++) {
+        uint64_t input_offset = 0;
+        uint64_t size = 0;
+        if (!non_negative_to_u64(offsets[list_idx], &input_offset) ||
+            !non_negative_to_u64(sizes[list_idx], &size)) {
+            atomicMax(status, 1u);
+            continue;
+        }
+
+        uint64_t input_end = 0;
+        if (!checked_add_u64(input_offset, size, &input_end) || input_end > elements_len) {
+            atomicMax(status, 1u);
+            continue;
+        }
+
+        const uint64_t output_idx = static_cast<uint64_t>(output_offsets[list_idx]);
+        for (uint64_t element_idx = 0; element_idx < size; element_idx++) {
+            const uint64_t input_byte = (input_offset + element_idx) * value_width;
+            const uint64_t output_byte = (output_idx + element_idx) * value_width;
+            for (uint64_t byte_idx = 0; byte_idx < value_width; byte_idx++) {
+                output_values[output_byte + byte_idx] = input_values[input_byte + byte_idx];
+            }
+        }
+    }
+}
+
+} // namespace
+
+#define GENERATE_VALIDATE_OFFSETS(SizeT, size_suffix)                                                        \
+    extern "C" __global__ void list_view_rebuild_validate_offsets_##size_suffix(                             \
+        const SizeT *const sizes,                                                                            \
+        const int32_t *const output_offsets,                                                                 \
+        uint32_t *const status,                                                                              \
+        uint64_t list_len) {                                                                                 \
+        list_view_rebuild_validate_offsets_device(sizes, output_offsets, status, list_len);                  \
+    }
+
+#define GENERATE_KERNEL(OffsetT, offset_suffix, SizeT, size_suffix)                                          \
+    extern "C" __global__ void list_view_offsets_##offset_suffix##_##size_suffix(                            \
+        const OffsetT *const offsets,                                                                        \
+        const SizeT *const sizes,                                                                            \
+        int32_t *const output,                                                                               \
+        uint32_t *const status,                                                                              \
+        uint64_t list_len) {                                                                                 \
+        list_view_offsets_device(offsets, sizes, output, status, list_len);                                  \
+    }                                                                                                        \
+    extern "C" __global__ void list_view_rebuild_primitive_##offset_suffix##_##size_suffix(                  \
+        const OffsetT *const offsets,                                                                        \
+        const SizeT *const sizes,                                                                            \
+        const int32_t *const output_offsets,                                                                 \
+        const uint8_t *const input_values,                                                                   \
+        uint8_t *const output_values,                                                                        \
+        uint32_t *const status,                                                                              \
+        uint64_t list_len,                                                                                   \
+        uint64_t elements_len,                                                                               \
+        uint64_t value_width) {                                                                              \
+        list_view_rebuild_primitive_device(offsets,                                                          \
+                                           sizes,                                                            \
+                                           output_offsets,                                                   \
+                                           input_values,                                                     \
+                                           output_values,                                                    \
+                                           status,                                                           \
+                                           list_len,                                                         \
+                                           elements_len,                                                     \
+                                           value_width);                                                     \
+    }
+
+#define GENERATE_INIT_SCAN(SizeT, size_suffix)                                                               \
+    extern "C" __global__ void list_view_rebuild_init_scan_##size_suffix(const SizeT *const sizes,           \
+                                                                         int32_t *const scan,                \
+                                                                         uint32_t *const status,             \
+                                                                         uint64_t list_len,                  \
+                                                                         uint64_t scan_len) {                \
+        list_view_rebuild_init_scan_device(sizes, scan, status, list_len, scan_len);                         \
+    }
+
+#define GENERATE_SIZE_KERNELS(OffsetT, offset_suffix)                                                        \
+    GENERATE_KERNEL(OffsetT, offset_suffix, uint8_t, u8)                                                     \
+    GENERATE_KERNEL(OffsetT, offset_suffix, uint16_t, u16)                                                   \
+    GENERATE_KERNEL(OffsetT, offset_suffix, uint32_t, u32)                                                   \
+    GENERATE_KERNEL(OffsetT, offset_suffix, uint64_t, u64)                                                   \
+    GENERATE_KERNEL(OffsetT, offset_suffix, int8_t, i8)                                                      \
+    GENERATE_KERNEL(OffsetT, offset_suffix, int16_t, i16)                                                    \
+    GENERATE_KERNEL(OffsetT, offset_suffix, int32_t, i32)                                                    \
+    GENERATE_KERNEL(OffsetT, offset_suffix, int64_t, i64)
+
+GENERATE_INIT_SCAN(uint8_t, u8)
+GENERATE_INIT_SCAN(uint16_t, u16)
+GENERATE_INIT_SCAN(uint32_t, u32)
+GENERATE_INIT_SCAN(uint64_t, u64)
+GENERATE_INIT_SCAN(int8_t, i8)
+GENERATE_INIT_SCAN(int16_t, i16)
+GENERATE_INIT_SCAN(int32_t, i32)
+GENERATE_INIT_SCAN(int64_t, i64)
+
+GENERATE_VALIDATE_OFFSETS(uint8_t, u8)
+GENERATE_VALIDATE_OFFSETS(uint16_t, u16)
+GENERATE_VALIDATE_OFFSETS(uint32_t, u32)
+GENERATE_VALIDATE_OFFSETS(uint64_t, u64)
+GENERATE_VALIDATE_OFFSETS(int8_t, i8)
+GENERATE_VALIDATE_OFFSETS(int16_t, i16)
+GENERATE_VALIDATE_OFFSETS(int32_t, i32)
+GENERATE_VALIDATE_OFFSETS(int64_t, i64)
+
+GENERATE_SIZE_KERNELS(uint8_t, u8)
+GENERATE_SIZE_KERNELS(uint16_t, u16)
+GENERATE_SIZE_KERNELS(uint32_t, u32)
+GENERATE_SIZE_KERNELS(uint64_t, u64)
+GENERATE_SIZE_KERNELS(int8_t, i8)
+GENERATE_SIZE_KERNELS(int16_t, i16)
+GENERATE_SIZE_KERNELS(int32_t, i32)
+GENERATE_SIZE_KERNELS(int64_t, i64)
diff --git a/vortex-cuda/src/arrow/canonical.rs b/vortex-cuda/src/arrow/canonical.rs
index 8d8b3779ec4..6c0f53ef249 100644
--- a/vortex-cuda/src/arrow/canonical.rs
+++ b/vortex-cuda/src/arrow/canonical.rs
@@ -2,38 +2,80 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::mem;
+use std::mem::size_of;
 use std::ptr;
+use std::sync::Arc;
 
 use async_trait::async_trait;
+use cudarc::driver::CudaSlice;
+use cudarc::driver::DeviceRepr;
+use cudarc::driver::LaunchConfig;
+use cudarc::driver::PushKernelArg;
+use cudarc::driver::result as cuda_driver;
 use futures::future::BoxFuture;
+use futures::future::join;
 use vortex::array::ArrayRef;
 use vortex::array::Canonical;
+use vortex::array::ExecutionCtx;
+use vortex::array::IntoArray;
+use vortex::array::arrays::DecimalArray;
+use vortex::array::arrays::Dict;
+use vortex::array::arrays::DictArray;
+use vortex::array::arrays::FixedSizeList;
+use vortex::array::arrays::FixedSizeListArray;
+use vortex::array::arrays::List;
+use vortex::array::arrays::ListArray;
+use vortex::array::arrays::ListView;
+use vortex::array::arrays::ListViewArray;
 use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::Struct;
 use vortex::array::arrays::StructArray;
+use vortex::array::arrays::VarBinViewArray;
 use vortex::array::arrays::bool::BoolDataParts;
 use vortex::array::arrays::decimal::DecimalDataParts;
+use vortex::array::arrays::dict::DictOwnedExt;
 use vortex::array::arrays::extension::ExtensionArrayExt;
+use vortex::array::arrays::fixed_size_list::FixedSizeListArrayExt;
+use vortex::array::arrays::fixed_size_list::FixedSizeListDataParts;
+use vortex::array::arrays::list::ListDataParts;
+use vortex::array::arrays::listview::ListViewArrayExt;
+use vortex::array::arrays::listview::list_from_list_view;
 use vortex::array::arrays::primitive::PrimitiveDataParts;
 use vortex::array::arrays::struct_::StructDataParts;
 use vortex::array::arrays::varbinview::VarBinViewDataParts;
 use vortex::array::buffer::BufferHandle;
+use vortex::array::builtins::ArrayBuiltins;
+use vortex::array::match_each_decimal_value_type;
 use vortex::array::validity::Validity;
 use vortex::buffer::Buffer;
-use vortex::buffer::ByteBuffer;
+use vortex::dtype::DType;
 use vortex::dtype::DecimalType;
+use vortex::dtype::NativeDecimalType;
+use vortex::dtype::Nullability;
+use vortex::dtype::PType;
+use vortex::dtype::i256;
 use vortex::error::VortexResult;
 use vortex::error::vortex_bail;
 use vortex::error::vortex_ensure;
+use vortex::error::vortex_err;
 use vortex::extension::datetime::AnyTemporal;
 use vortex::mask::Mask;
 
+use crate::CudaBufferExt;
+use crate::CudaDeviceBuffer;
 use crate::CudaExecutionCtx;
 use crate::arrow::ARROW_DEVICE_CUDA;
 use crate::arrow::ArrowArray;
 use crate::arrow::ArrowDeviceArray;
+use crate::arrow::ArrowDeviceArrayWithSchema;
 use crate::arrow::ExportDeviceArray;
 use crate::arrow::PrivateData;
 use crate::arrow::SyncEvent;
+use crate::arrow::arrow_device_export_dictionary_codes_dtype;
+use crate::arrow::arrow_schema_for_array;
+use crate::arrow::cuda_decimal_value_type;
+use crate::arrow::list_view::export_device_list_view;
+use crate::cub::exclusive_sum_i32;
 use crate::executor::CudaArrayExt;
 
 /// An implementation of `ExportDeviceArray` that exports Vortex arrays to `ArrowDeviceArray` by
@@ -49,9 +91,7 @@ impl ExportDeviceArray for CanonicalDeviceArrayExport {
         array: ArrayRef,
         ctx: &mut CudaExecutionCtx,
     ) -> VortexResult<ArrowDeviceArray> {
-        let cuda_array = array.execute_cuda(ctx).await?;
-
-        let (arrow_array, sync_event) = export_canonical(cuda_array, ctx).await?;
+        let (arrow_array, sync_event) = export_array(array, ctx).await?;
 
         Ok(ArrowDeviceArray {
             array: arrow_array,
@@ -61,8 +101,131 @@ impl ExportDeviceArray for CanonicalDeviceArrayExport {
             reserved: Default::default(),
         })
     }
+
+    async fn export_device_array_with_schema(
+        &self,
+        array: ArrayRef,
+        ctx: &mut CudaExecutionCtx,
+    ) -> VortexResult<ArrowDeviceArrayWithSchema> {
+        let array = rebuild_array_for_export_schema(array, ctx.execution_ctx())?;
+        let schema = arrow_schema_for_array(&array, ctx)?;
+        let array = self.export_device_array(array, ctx).await?;
+        Ok(ArrowDeviceArrayWithSchema { schema, array })
+    }
+}
+
+/// Rebuild arrays whose exported layout differs from their original layout.
+fn rebuild_array_for_export_schema(
+    array: ArrayRef,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ArrayRef> {
+    let array = match array.try_downcast::<Dict>() {
+        Ok(dict) => {
+            let parts = dict.into_parts();
+            let values = rebuild_array_for_export_schema(parts.values, ctx)?;
+            return Ok(DictArray::try_new(parts.codes, values)?.into_array());
+        }
+        Err(array) => array,
+    };
+    let array = match array.try_downcast::<Struct>() {
+        Ok(struct_array) => {
+            let len = struct_array.len();
+            let StructDataParts {
+                struct_fields,
+                fields,
+                validity,
+            } = struct_array.into_data_parts();
+            let fields = fields
+                .iter()
+                .map(|field| rebuild_array_for_export_schema(field.clone(), ctx))
+                .collect::<VortexResult<Vec<_>>>()?;
+            return Ok(
+                StructArray::try_new(struct_fields.names().clone(), fields, len, validity)?
+                    .into_array(),
+            );
+        }
+        Err(array) => array,
+    };
+    let array = match array.try_downcast::<List>() {
+        Ok(list) => {
+            let ListDataParts {
+                elements,
+                offsets,
+                validity,
+                ..
+            } = list.into_data_parts();
+            let elements = rebuild_array_for_export_schema(elements, ctx)?;
+            return Ok(ListArray::try_new(elements, offsets, validity)?.into_array());
+        }
+        Err(array) => array,
+    };
+    let array = match array.try_downcast::<FixedSizeList>() {
+        Ok(fixed_size_list) => {
+            let len = fixed_size_list.len();
+            let list_size = fixed_size_list.list_size();
+            let FixedSizeListDataParts {
+                elements, validity, ..
+            } = fixed_size_list.into_data_parts();
+            let elements = rebuild_array_for_export_schema(elements, ctx)?;
+            return Ok(
+                FixedSizeListArray::try_new(elements, list_size, validity, len)?.into_array(),
+            );
+        }
+        Err(array) => array,
+    };
+    let array = match array.try_downcast::<ListView>() {
+        Ok(listview)
+            if listview.as_ref().is_host() && listview.elements().as_opt::<Dict>().is_some() =>
+        {
+            return rebuild_array_for_export_schema(
+                list_from_list_view(listview, ctx)?.into_array(),
+                ctx,
+            );
+        }
+        Ok(listview) => return Ok(listview.into_array()),
+        Err(array) => array,
+    };
+
+    Ok(array)
+}
+
+/// Export arrays whose Arrow layout depends on their concrete children before CUDA
+/// canonicalization can erase that structure (for example nested dictionaries).
+/// All other arrays are executed on CUDA, then exported directly from the canonical result.
+fn export_array(
+    array: ArrayRef,
+    ctx: &mut CudaExecutionCtx,
+) -> BoxFuture<'_, VortexResult<(ArrowArray, SyncEvent)>> {
+    Box::pin(async {
+        let array = match array.try_downcast::<Dict>() {
+            Ok(dict) => return export_dict(dict, ctx).await,
+            Err(array) => array,
+        };
+        let array = match array.try_downcast::<Struct>() {
+            Ok(struct_array) => return export_struct(struct_array, ctx).await,
+            Err(array) => array,
+        };
+        let array = match array.try_downcast::<List>() {
+            Ok(list) => {
+                return export_list(list, ListChildExport::PreserveConcreteLayout, ctx).await;
+            }
+            Err(array) => array,
+        };
+        let array = match array.try_downcast::<FixedSizeList>() {
+            Ok(fixed_size_list) => return export_fixed_size_list(fixed_size_list, ctx).await,
+            Err(array) => array,
+        };
+        let array = match array.try_downcast::<ListView>() {
+            Ok(list_view) => return export_list_view(list_view, ctx).await,
+            Err(array) => array,
+        };
+
+        let cuda_array = array.execute_cuda(ctx).await?;
+        export_canonical(cuda_array, ctx).await
+    })
 }
 
+/// Export a canonical CUDA array using the Arrow C Device layout for its logical type.
 fn export_canonical(
     cuda_array: Canonical,
     ctx: &mut CudaExecutionCtx,
@@ -94,27 +257,7 @@ fn export_canonical(
                 // we don't need a sync event for Null since no data is copied.
                 Ok((array, ptr::null_mut()))
             }
-            Canonical::Decimal(decimal) => {
-                let len = decimal.len();
-                let DecimalDataParts {
-                    values,
-                    values_type,
-                    validity,
-                    ..
-                } = decimal.into_data_parts();
-
-                // TODO(aduffy): GPU kernel for upcasting.
-                vortex_ensure!(
-                    values_type >= DecimalType::I32,
-                    "cannot export DecimalArray with values type {values_type}. must be i32 or wider."
-                );
-
-                let (validity_buffer, null_count) =
-                    export_arrow_validity_buffer(validity, len, 0, ctx).await?;
-                let buffer = ctx.ensure_on_device(values).await?;
-
-                export_fixed_size(buffer, len, 0, validity_buffer, null_count, ctx)
-            }
+            Canonical::Decimal(decimal) => export_decimal(decimal, ctx).await,
             Canonical::Extension(extension) => {
                 if !extension.ext_dtype().is::<AnyTemporal>() {
                     vortex_bail!("only support temporal extension types currently");
@@ -139,17 +282,30 @@ fn export_canonical(
             Canonical::Bool(bool_array) => {
                 let len = bool_array.len();
                 let validity = bool_array.validity()?;
-                let BoolDataParts {
-                    bits, offset, len, ..
-                } = bool_array.into_data().into_parts(len);
+                let BoolDataParts { bits, meta } = bool_array.into_data().into_parts(len);
 
                 let (validity_buffer, null_count) =
-                    export_arrow_validity_buffer(validity, len, offset, ctx).await?;
+                    export_arrow_validity_buffer(validity, len, meta.offset(), ctx).await?;
 
                 let bits = ctx.ensure_on_device(bits).await?;
-                export_fixed_size(bits, len, offset, validity_buffer, null_count, ctx)
+                export_fixed_size(
+                    bits,
+                    meta.len(),
+                    meta.offset(),
+                    validity_buffer,
+                    null_count,
+                    ctx,
+                )
+            }
+            Canonical::List(listview) => export_list_view(listview, ctx).await,
+            Canonical::FixedSizeList(fixed_size_list) => {
+                export_fixed_size_list(fixed_size_list, ctx).await
             }
             Canonical::VarBinView(varbinview) => {
+                if matches!(varbinview.dtype(), DType::Binary(_)) {
+                    return export_binary(varbinview, ctx).await;
+                }
+
                 let len = varbinview.len();
                 let VarBinViewDataParts {
                     views,
@@ -206,10 +362,412 @@ fn export_canonical(
     })
 }
 
-/// Export Vortex validity as an Arrow validity byte buffer.
+/// Export a Vortex dictionary array as an Arrow Device dictionary array.
+///
+/// Owns the codes buffers and recursively exported dictionary values.
+async fn export_dict(
+    array: DictArray,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<(ArrowArray, SyncEvent)> {
+    let len = array.len();
+    let parts = array.into_parts();
+    let PrimitiveDataParts {
+        buffer, validity, ..
+    } = export_dictionary_codes(parts.codes, ctx).await?;
+    let (validity_buffer, null_count) = export_arrow_validity_buffer(validity, len, 0, ctx).await?;
+    let codes_buffer = ctx.ensure_on_device(buffer).await?;
+    let (dictionary, _) = export_array(parts.values, ctx).await?;
+
+    let mut private_data = PrivateData::new_with_dictionary(
+        vec![validity_buffer, Some(codes_buffer)],
+        vec![],
+        Some(dictionary),
+        ctx,
+    )?;
+    let sync_event = private_data.sync_event();
+    let dictionary = private_data.dictionary;
+
+    let arrow_array = ArrowArray {
+        length: len as i64,
+        null_count,
+        offset: 0,
+        n_buffers: 2,
+        buffers: private_data.buffer_ptrs.as_mut_ptr(),
+        n_children: 0,
+        children: ptr::null_mut(),
+        release: Some(release_array),
+        dictionary,
+        private_data: Box::into_raw(private_data).cast(),
+    };
+
+    Ok((arrow_array, sync_event))
+}
+
+async fn export_dictionary_codes(
+    codes: ArrayRef,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<PrimitiveDataParts> {
+    let target_dtype = arrow_device_export_dictionary_codes_dtype(codes.dtype())?;
+    let target_ptype = target_dtype.as_ptype();
+    let codes = if codes.dtype() == &target_dtype {
+        codes
+    } else {
+        codes.cast(target_dtype)?
+    }
+    .execute_cuda(ctx)
+    .await?;
+    let Canonical::Primitive(codes) = codes else {
+        vortex_bail!("dictionary codes must be primitive, got {}", codes.dtype());
+    };
+
+    let parts = codes.into_data_parts();
+    vortex_ensure!(
+        parts.ptype == target_ptype,
+        "dictionary codes export produced {}",
+        parts.ptype
+    );
+    Ok(parts)
+}
+
+/// Exports decimals with value buffers cast to Arrow's Decimal32/64/128/256 layout.
+///
+/// Decimal values are already decoded; this only adapts the physical buffer width. Storage-to-Arrow
+/// narrowing is rejected instead of checked on-device to avoid a device-to-host synchronization
+/// point.
+async fn export_decimal(
+    decimal: DecimalArray,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<(ArrowArray, SyncEvent)> {
+    let len = decimal.len();
+    let DecimalDataParts {
+        decimal_dtype,
+        values,
+        values_type,
+        validity,
+    } = decimal.into_data_parts();
+
+    let (validity_buffer, null_count) = export_arrow_validity_buffer(validity, len, 0, ctx).await?;
+    let target_type = cuda_decimal_value_type(decimal_dtype);
+    let values = export_decimal_values(values, values_type, target_type, len, ctx).await?;
+
+    export_fixed_size(values, len, 0, validity_buffer, null_count, ctx)
+}
+
+/// Ensure the values buffer is on-device and has the Arrow-required decimal width.
+///
+/// Storage wider than the precision-implied Arrow width is rejected. Callers that hit this
+/// should narrow the storage via a decimal cast before exporting.
+async fn export_decimal_values(
+    values: BufferHandle,
+    values_type: DecimalType,
+    target_type: DecimalType,
+    len: usize,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<BufferHandle> {
+    if values_type.byte_width() > target_type.byte_width() {
+        vortex_bail!(
+            "cannot export decimal values from {values_type} storage to Arrow {target_type}: narrowing would require a device-to-host overflow check",
+        );
+    }
+    let values = ctx.ensure_on_device(values).await?;
+    if values_type == target_type {
+        return Ok(values);
+    }
+
+    match_each_decimal_value_type!(values_type, |S| {
+        export_decimal_values_from::<S>(values, target_type, len, ctx).await
+    })
+}
+
+/// Dispatch from a concrete storage type `S` to the Arrow-required output width.
+async fn export_decimal_values_from<S>(
+    values: BufferHandle,
+    target_type: DecimalType,
+    len: usize,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<BufferHandle>
+where
+    S: NativeDecimalType + DeviceRepr,
+{
+    match target_type {
+        DecimalType::I32 => decimal_cast::<S, i32>(values, len, ctx).await,
+        DecimalType::I64 => decimal_cast::<S, i64>(values, len, ctx).await,
+        DecimalType::I128 => decimal_cast::<S, i128>(values, len, ctx).await,
+        DecimalType::I256 => decimal_cast::<S, i256>(values, len, ctx).await,
+        target_type => {
+            vortex_bail!("cannot export DecimalArray as Arrow decimal value type {target_type}")
+        }
+    }
+}
+
+/// Launches the CUDA kernel that casts from Vortex storage type `S` to Arrow output type `D`.
+///
+/// The caller must ensure this is not a narrowing cast.
+async fn decimal_cast<S, D>(
+    values: BufferHandle,
+    len: usize,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<BufferHandle>
+where
+    S: NativeDecimalType + DeviceRepr,
+    D: NativeDecimalType + DeviceRepr,
+{
+    if len == 0 {
+        return ctx
+            .ensure_on_device(BufferHandle::new_host(
+                Buffer::<D>::empty().into_byte_buffer(),
+            ))
+            .await;
+    }
+
+    let output_buffer = ctx.device_alloc::<D>(len)?;
+    let output_device = CudaDeviceBuffer::new(output_buffer);
+
+    let values_view = values.cuda_view::<S>()?;
+    let output_view = output_device.as_view::<D>();
+    let len_u64 = len as u64;
+    let cuda_function = ctx.load_function_with_suffixes(
+        "decimal_cast",
+        &[&S::DECIMAL_TYPE.to_string(), &D::DECIMAL_TYPE.to_string()],
+    )?;
+
+    ctx.launch_kernel(&cuda_function, len, |args| {
+        args.arg(&values_view).arg(&output_view).arg(&len_u64);
+    })?;
+
+    Ok(BufferHandle::new_device(Arc::new(output_device)))
+}
+
+/// Export Vortex binary views as an Arrow Device array with standard `Binary` layout.
+async fn export_binary(
+    varbinview: VarBinViewArray,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<(ArrowArray, SyncEvent)> {
+    let len = varbinview.len();
+    let VarBinViewDataParts {
+        views,
+        buffers: data_buffers,
+        validity,
+        ..
+    } = varbinview.into_data_parts();
+
+    let (validity_buffer, null_count) = export_arrow_validity_buffer(validity, len, 0, ctx).await?;
+    let views = ctx.ensure_on_device(views).await?;
+    let (offsets, values) =
+        export_binary_buffers(&views, &data_buffers, validity_buffer.as_ref(), len, ctx).await?;
+
+    let buffers = vec![validity_buffer, Some(offsets), Some(values)];
+
+    let mut private_data = PrivateData::new(buffers, vec![], ctx)?;
+    let sync_event = private_data.sync_event();
+    let arrow_array = ArrowArray {
+        length: len as i64,
+        null_count,
+        offset: 0,
+        // Arrow Binary layout: optional null bitmap, i32 offsets, contiguous bytes.
+        n_buffers: 3,
+        buffers: private_data.buffer_ptrs.as_mut_ptr(),
+        n_children: 0,
+        children: ptr::null_mut(),
+        release: Some(release_array),
+        dictionary: ptr::null_mut(),
+        private_data: Box::into_raw(private_data).cast(),
+    };
+
+    Ok((arrow_array, sync_event))
+}
+
+/// Build Arrow Binary offsets and values from VarBinView buffers on the active CUDA stream.
+async fn export_binary_buffers(
+    views: &BufferHandle,
+    data_buffers: &[BufferHandle],
+    validity: Option<&BufferHandle>,
+    len: usize,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<(BufferHandle, BufferHandle)> {
+    let mut device_data_buffers = Vec::with_capacity(data_buffers.len());
+    for buffer in data_buffers {
+        device_data_buffers.push(ctx.ensure_on_device(buffer.clone()).await?);
+    }
+
+    let mut ptr_values = Vec::with_capacity(device_data_buffers.len());
+    let mut len_values = Vec::with_capacity(device_data_buffers.len());
+    for buffer in &device_data_buffers {
+        ptr_values.push(buffer.cuda_device_ptr()?);
+        len_values.push(u64::try_from(buffer.len())?);
+    }
+    if device_data_buffers.is_empty() {
+        // Kernels never dereference these when data_buffer_count is zero, but the arguments
+        // still need a real device allocation.
+        ptr_values.push(0);
+        len_values.push(0);
+    }
+    let data_buffer_ptrs = device_buffer_from(ptr_values, ctx).await?;
+    let data_buffer_lens = device_buffer_from(len_values, ctx).await?;
+    let status = device_buffer_from(vec![0u32], ctx).await?;
+
+    let scan_input = init_binary_scan(
+        views,
+        validity,
+        &data_buffer_lens,
+        device_data_buffers.len(),
+        &status,
+        len,
+        ctx,
+    )?;
+    let output_offsets = BufferHandle::new_device(Arc::new(CudaDeviceBuffer::new(
+        exclusive_sum_i32(&scan_input, len + 1, ctx)?,
+    )));
+    validate_binary_offsets(&output_offsets, len, &status, ctx)?;
+
+    // One status read covers init_scan and offset validation. Both must pass before gather may
+    // dereference view payloads through the scanned offsets. Enqueue both copies up front so the
+    // readbacks share one stream round-trip; await both so an error cannot drop a copy mid-flight.
+    let status_copy = status.try_to_host()?;
+    let total_copy = output_offsets
+        .slice_typed::<i32>(len..len + 1)
+        .try_to_host()?;
+    let (status_value, total_value) = join(status_copy, total_copy).await;
+
+    check_binary_status(Buffer::<u32>::from_byte_buffer(status_value?)[0])?;
+    let total_bytes = usize::try_from(Buffer::<i32>::from_byte_buffer(total_value?)[0])?;
+    let output_values = gather_binary_values(
+        views,
+        &data_buffer_ptrs,
+        &output_offsets,
+        total_bytes,
+        len,
+        ctx,
+    )?;
+
+    Ok((output_offsets, output_values))
+}
+
+/// Copy a small host vector to a device-resident buffer.
+async fn device_buffer_from<T>(
+    values: Vec<T>,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<BufferHandle>
+where
+    Buffer<T>: From<Vec<T>>,
+{
+    ctx.ensure_on_device(BufferHandle::new_host(
+        Buffer::from(values).into_byte_buffer(),
+    ))
+    .await
+}
+
+fn check_binary_status(status: u32) -> VortexResult<()> {
+    match status {
+        0 => Ok(()),
+        1 => vortex_bail!(
+            "cannot export BinaryView as Arrow Binary: a view references an invalid data buffer"
+        ),
+        2 => vortex_bail!(
+            "cannot export BinaryView as Arrow Binary: offsets exceed i32 range required by Arrow Binary"
+        ),
+        status => vortex_bail!("unexpected Arrow Binary export status {status}"),
+    }
+}
+
+fn init_binary_scan(
+    views: &BufferHandle,
+    validity: Option<&BufferHandle>,
+    data_buffer_lens: &BufferHandle,
+    data_buffer_count: usize,
+    status: &BufferHandle,
+    len: usize,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<CudaSlice<i32>> {
+    let scan_len = len + 1;
+    let views_view = views.cuda_view::<u8>()?;
+    // A null pointer signals an all-valid array to the kernel.
+    let validity_ptr = validity
+        .map(|v| v.cuda_device_ptr())
+        .transpose()?
+        .unwrap_or(0);
+    let lens_view = data_buffer_lens.cuda_view::<u64>()?;
+    let status_view = status.cuda_view::<u32>()?;
+    let data_buffer_count_u64 = data_buffer_count as u64;
+    let len_u64 = len as u64;
+    let scan_input = ctx.device_alloc::<i32>(scan_len)?;
+    let kernel = ctx.load_function_with_suffixes("arrow_binary", &["init_scan"])?;
+
+    ctx.launch_kernel(&kernel, scan_len, |args| {
+        args.arg(&views_view)
+            .arg(&validity_ptr)
+            .arg(&lens_view)
+            .arg(&scan_input)
+            .arg(&status_view)
+            .arg(&data_buffer_count_u64)
+            .arg(&len_u64);
+    })?;
+
+    Ok(scan_input)
+}
+
+/// Flag scanned offsets that overflowed i32. A negative offset is proof of overflow because
+/// init_scan caps every row size at `i32::MAX`, so the first overflowing prefix sum always wraps
+/// into the negative range.
+fn validate_binary_offsets(
+    offsets: &BufferHandle,
+    len: usize,
+    status: &BufferHandle,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<()> {
+    let scan_len = len + 1;
+    let offsets_view = offsets.cuda_view::<i32>()?;
+    let status_view = status.cuda_view::<u32>()?;
+    let scan_len_u64 = scan_len as u64;
+    let kernel = ctx.load_function_with_suffixes("arrow_binary", &["validate_offsets"])?;
+
+    ctx.launch_kernel(&kernel, scan_len, |args| {
+        args.arg(&offsets_view).arg(&status_view).arg(&scan_len_u64);
+    })
+}
+
+fn gather_binary_values(
+    views: &BufferHandle,
+    data_buffer_ptrs: &BufferHandle,
+    offsets: &BufferHandle,
+    total_bytes: usize,
+    len: usize,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<BufferHandle> {
+    let output_values = ctx.device_alloc::<u8>(total_bytes.max(1))?;
+
+    if total_bytes != 0 {
+        let views_view = views.cuda_view::<u8>()?;
+        let ptrs_view = data_buffer_ptrs.cuda_view::<u64>()?;
+        let offsets_view = offsets.cuda_view::<i32>()?;
+        let len_u64 = len as u64;
+        let total_bytes_u64 = total_bytes as u64;
+        let kernel = ctx.load_function_with_suffixes("arrow_binary", &["gather"])?;
+
+        ctx.launch_kernel(&kernel, total_bytes, |args| {
+            args.arg(&views_view)
+                .arg(&ptrs_view)
+                .arg(&offsets_view)
+                .arg(&output_values)
+                .arg(&len_u64)
+                .arg(&total_bytes_u64);
+        })?;
+    }
+
+    Ok(
+        BufferHandle::new_device(Arc::new(CudaDeviceBuffer::new(output_values)))
+            .slice(0..total_bytes),
+    )
+}
+
+/// Export Vortex validity as an Arrow Device validity byte buffer.
 ///
 /// Returns `None` for the buffer when Arrow can omit validity because all rows are valid.
-async fn export_arrow_validity_buffer(
+///
+/// Returned buffers use zeroed 4-byte padding so cuDF's word-sized mask reads stay in bounds.
+/// Bits at positions `>= len + arrow_offset` within the final data byte are unspecified, as
+/// Arrow permits.
+pub(super) async fn export_arrow_validity_buffer(
     validity: Validity,
     len: usize,
     arrow_offset: usize,
@@ -222,14 +780,297 @@ async fn export_arrow_validity_buffer(
 
     let validity_buffer = match mask {
         Mask::AllTrue(_) => return Ok((None, 0)),
-        Mask::AllFalse(_) => ByteBuffer::zeroed(validity_bytes),
-        values @ Mask::Values(_) => values.into_bit_buffer().into_inner().2,
+        Mask::AllFalse(_) => device_zeroed_byte_buffer(validity_bytes, ctx)?,
+        Mask::Values(values) => {
+            // Shrinking the offset below 8 bounds the host-to-device copy to the slice's bytes
+            // instead of the whole backing bitmap.
+            let bits = values.bit_buffer().clone().shrink_offset();
+            if arrow_offset == 0 && bits.offset() == 0 {
+                // Fast path: the Vortex bitmap already matches Arrow's byte-addressed layout.
+                let (_, _, buffer) = bits.into_inner();
+                ctx.ensure_on_device(BufferHandle::new_host(buffer)).await?
+            } else {
+                // Slow path: bit offsets cannot be represented by the Arrow buffer pointer.
+                // Repack on the GPU so compact/sliced exports keep Arrow offset semantics.
+                let (input_offset, _, input_buffer) = bits.into_inner();
+                let input_buffer = ctx
+                    .ensure_on_device(BufferHandle::new_host(input_buffer))
+                    .await?;
+                repack_arrow_validity_buffer(&input_buffer, input_offset, len, arrow_offset, ctx)?
+            }
+        }
     };
-    let validity = ctx
-        .ensure_on_device(BufferHandle::new_host(validity_buffer))
-        .await?;
 
-    Ok((Some(validity), null_count))
+    Ok((Some(validity_buffer), null_count))
+}
+
+/// Allocate a zeroed device buffer with cuDF-safe padding for Arrow validity masks.
+fn device_zeroed_byte_buffer(
+    byte_len: usize,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<BufferHandle> {
+    let allocation_len = byte_len.next_multiple_of(size_of::<u32>()).max(1);
+    let mut buffer = ctx.device_alloc::<u8>(allocation_len)?;
+    ctx.stream()
+        .memset_zeros(&mut buffer)
+        .map_err(|err| vortex_err!("Failed to zero Arrow validity buffer: {err}"))?;
+    Ok(BufferHandle::new_device(Arc::new(CudaDeviceBuffer::new(buffer))).slice(0..byte_len))
+}
+
+/// Repack a validity bitmap into Arrow layout without copying bitmap bits back to the CPU.
+///
+/// Vortex bitmaps may start at any bit offset. Arrow exposes only a byte-addressed validity buffer
+/// plus an array offset, so sliced compact exports need a GPU rewrite when either side has a
+/// bit-level offset. The kernel writes the output one 64-bit word at a time, funnel-shifting two
+/// adjacent input words, so the allocation is padded to whole words (zeroed by the edge masks).
+pub(super) fn repack_arrow_validity_buffer(
+    input_buffer: &BufferHandle,
+    input_offset: usize,
+    len: usize,
+    arrow_offset: usize,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<BufferHandle> {
+    let validity_bits = len
+        .checked_add(arrow_offset)
+        .ok_or_else(|| vortex_err!("Arrow validity bit length overflows usize"))?;
+    let output_bytes = validity_bits.div_ceil(8);
+    let output_words = validity_bits.div_ceil(u64::BITS as usize);
+
+    // The kernel loads the input bitmap as 64-bit words.
+    if !input_buffer
+        .cuda_device_ptr()?
+        .is_multiple_of(size_of::<u64>() as u64)
+    {
+        vortex_bail!("Arrow validity repack requires an 8-byte aligned device buffer");
+    }
+
+    let output = ctx.device_alloc::<u64>(output_words.max(1))?;
+    let output_device = CudaDeviceBuffer::new(output);
+
+    if output_words > 0 {
+        let input_view = input_buffer.cuda_view::<u8>()?;
+        let output_view = output_device.as_view::<u64>();
+        let len = u64::try_from(len)?;
+        let input_offset = u64::try_from(input_offset)?;
+        let arrow_offset = u64::try_from(arrow_offset)?;
+        let input_bytes = u64::try_from(input_buffer.len())?;
+
+        let kernel = ctx.load_function_with_suffixes("arrow_validity", &["repack"])?;
+        const REPACK_THREADS_PER_BLOCK: u32 = 256;
+        let num_blocks = u32::try_from(output_words.div_ceil(REPACK_THREADS_PER_BLOCK as usize))?;
+        let config = LaunchConfig {
+            grid_dim: (num_blocks, 1, 1),
+            block_dim: (REPACK_THREADS_PER_BLOCK, 1, 1),
+            shared_mem_bytes: 0,
+        };
+        ctx.launch_kernel_config(&kernel, config, output_words, |args| {
+            args.arg(&input_view)
+                .arg(&output_view)
+                .arg(&len)
+                .arg(&input_offset)
+                .arg(&arrow_offset)
+                .arg(&input_bytes);
+        })?;
+    }
+
+    Ok(BufferHandle::new_device(Arc::new(output_device)).slice(0..output_bytes))
+}
+
+/// Export a Vortex list-view as an Arrow Device array with `List` layout.
+async fn export_list_view(
+    listview: ListViewArray,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<(ArrowArray, SyncEvent)> {
+    // cuDF imports standard Arrow `List`, while Vortex canonical lists are list-views.
+    // Try the GPU path first; host list-views can fall back to a CPU rebuild.
+    let is_host = listview.as_ref().is_host();
+    let gpu_err = match export_device_list_view(listview.clone(), ctx).await {
+        Ok(exported) => return Ok(exported),
+        Err(err) => err,
+    };
+
+    // CPU rebuild requires host-resident buffers; device-resident arrays keep the GPU error.
+    if !is_host {
+        return Err(gpu_err);
+    }
+
+    // The CPU fallback packs ListView ranges into a contiguous List.
+    export_list(
+        list_from_list_view(listview, ctx.execution_ctx())?,
+        ListChildExport::RebuiltListViewChild,
+        ctx,
+    )
+    .await
+}
+
+/// Export a standard Vortex list as an Arrow Device array with `List` layout.
+async fn export_list(
+    array: ListArray,
+    child_export: ListChildExport,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<(ArrowArray, SyncEvent)> {
+    let len = array.len();
+    let ListDataParts {
+        elements,
+        offsets,
+        validity,
+        ..
+    } = array.into_data_parts();
+
+    let (validity_buffer, null_count) = export_arrow_validity_buffer(validity, len, 0, ctx).await?;
+    let offsets_buffer = export_arrow_list_offsets(offsets, ctx).await?;
+    export_list_layout(
+        elements,
+        len,
+        validity_buffer,
+        null_count,
+        offsets_buffer,
+        child_export,
+        ctx,
+    )
+    .await
+}
+
+#[derive(Clone, Copy)]
+pub(super) enum ListChildExport {
+    /// Preserve concrete child layouts, such as dictionaries,
+    /// so exported data matches the schema.
+    PreserveConcreteLayout,
+    /// Canonicalize temporary encodings introduced by the host ListView
+    /// rebuild, while still preserving rebuilt dictionary children.
+    ///
+    /// This is not equivalent to `export_array`: the take-based rebuild wraps
+    /// children in transient encodings (for example `take` returns `Dict`
+    /// arrays nested inside struct fields) that the pre-computed export schema
+    /// does not include, so they must be canonicalized away before export.
+    RebuiltListViewChild,
+}
+
+impl ListChildExport {
+    async fn export(
+        self,
+        elements: ArrayRef,
+        ctx: &mut CudaExecutionCtx,
+    ) -> VortexResult<ArrowArray> {
+        let (elements_child, _) = match self {
+            ListChildExport::PreserveConcreteLayout => export_array(elements, ctx).await?,
+            ListChildExport::RebuiltListViewChild if elements.as_opt::<Dict>().is_some() => {
+                export_array(elements, ctx).await?
+            }
+            ListChildExport::RebuiltListViewChild => {
+                export_canonical(elements.execute_cuda(ctx).await?, ctx).await?
+            }
+        };
+        Ok(elements_child)
+    }
+}
+
+/// Build the shared Arrow Device `List` parent once offsets and validity are ready.
+pub(super) async fn export_list_layout(
+    elements: ArrayRef,
+    len: usize,
+    validity_buffer: Option<BufferHandle>,
+    null_count: i64,
+    offsets_buffer: BufferHandle,
+    child_export: ListChildExport,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<(ArrowArray, SyncEvent)> {
+    let elements_child = child_export.export(elements, ctx).await?;
+
+    let mut private_data = PrivateData::new(
+        vec![validity_buffer, Some(offsets_buffer)],
+        vec![elements_child],
+        ctx,
+    )?;
+    let sync_event = private_data.sync_event();
+
+    let mut arrow_list = ArrowArray::empty();
+    arrow_list.length = len as i64;
+    arrow_list.null_count = null_count;
+    arrow_list.n_buffers = 2;
+    arrow_list.buffers = private_data.buffer_ptrs.as_mut_ptr();
+    arrow_list.n_children = 1;
+    arrow_list.children = private_data.children.as_mut_ptr();
+    arrow_list.release = Some(release_array);
+    arrow_list.private_data = Box::into_raw(private_data).cast();
+
+    Ok((arrow_list, sync_event))
+}
+
+/// Export a Vortex fixed-size-list as an Arrow Device array with `List` layout.
+///
+/// cuDF's Arrow Device import accepts `List`/`LargeList` as cuDF `LIST`, but rejects
+/// `FixedSizeList`, so emit equivalent standard Arrow `List` offsets.
+async fn export_fixed_size_list(
+    array: FixedSizeListArray,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<(ArrowArray, SyncEvent)> {
+    let len = array.len();
+    let list_size = array.list_size();
+    let FixedSizeListDataParts {
+        elements, validity, ..
+    } = array.into_data_parts();
+
+    let (validity_buffer, null_count) = export_arrow_validity_buffer(validity, len, 0, ctx).await?;
+    let offsets_buffer = fixed_size_list_offsets(len, list_size, ctx).await?;
+
+    export_list_layout(
+        elements,
+        len,
+        validity_buffer,
+        null_count,
+        offsets_buffer,
+        ListChildExport::PreserveConcreteLayout,
+        ctx,
+    )
+    .await
+}
+
+async fn fixed_size_list_offsets(
+    len: usize,
+    list_size: u32,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<BufferHandle> {
+    let list_size = i32::try_from(list_size).map_err(|_| {
+        vortex_err!(
+            "cannot export FixedSizeList with list size {list_size}: Arrow List offsets require i32"
+        )
+    })?;
+    let offsets = (0..=i32::try_from(len)?)
+        .map(|idx| {
+            idx.checked_mul(list_size)
+                .ok_or_else(|| vortex_err!("FixedSizeList Arrow List offsets exceed i32 range"))
+        })
+        .collect::<VortexResult<Vec<_>>>()?;
+
+    ctx.ensure_on_device(BufferHandle::new_host(
+        Buffer::from(offsets).into_byte_buffer(),
+    ))
+    .await
+}
+
+/// Return Arrow Device `List` offsets as an `i32` device buffer.
+async fn export_arrow_list_offsets(
+    offsets: ArrayRef,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<BufferHandle> {
+    let offsets = if offsets.dtype().as_ptype() == PType::I32 {
+        offsets
+    } else {
+        offsets.cast(DType::Primitive(PType::I32, Nullability::NonNullable))?
+    };
+    let offsets = offsets.execute_cuda(ctx).await?;
+    let Canonical::Primitive(offsets) = offsets else {
+        vortex_bail!("list offsets must be primitive, got {}", offsets.dtype());
+    };
+
+    let PrimitiveDataParts { ptype, buffer, .. } = offsets.into_data_parts();
+    vortex_ensure!(
+        ptype == PType::I32,
+        "list offsets cast to i32 produced {ptype}"
+    );
+
+    ctx.ensure_on_device(buffer).await
 }
 
 async fn export_struct(
@@ -247,8 +1088,7 @@ async fn export_struct(
     let mut children = Vec::with_capacity(fields.len());
 
     for field in fields.iter() {
-        let cuda_field = field.clone().execute_cuda(ctx).await?;
-        let (arrow_field, _) = export_canonical(cuda_field, ctx).await?;
+        let (arrow_field, _) = export_array(field.clone(), ctx).await?;
         children.push(arrow_field);
     }
 
@@ -319,7 +1159,15 @@ unsafe extern "C" fn release_array(array: *mut ArrowArray) {
 
         if !private_data_ptr.is_null() {
             let mut private_data = Box::from_raw(private_data_ptr.cast::<PrivateData>());
+            // Release may run on a foreign thread; bind this array's context before synchronizing
+            // so async frees cannot race consumer-side reads.
+            let cuda_context = Arc::clone(private_data.cuda_stream.context());
+            match cuda_context.bind_to_thread() {
+                Ok(()) => cuda_context.record_err(cuda_driver::ctx::synchronize()),
+                Err(err) => cuda_context.record_err(Err::<(), _>(err)),
+            }
             release_children(&mut private_data);
+            release_dictionary(&mut private_data);
         }
 
         // update the release function to NULL to avoid any possibility of double-frees.
@@ -327,18 +1175,34 @@ unsafe extern "C" fn release_array(array: *mut ArrowArray) {
     }
 }
 
+/// Release all owned child arrays stored in private data.
 unsafe fn release_children(private_data: &mut PrivateData) {
     unsafe {
         let children = mem::take(&mut private_data.children);
         for child in children {
-            if !child.is_null() {
-                if let Some(release) = (*child).release {
-                    release(child);
-                }
-                // Children are allocated with Box::into_raw in PrivateData::new, so the
-                // release callback must also reclaim the ArrowArray allocation itself.
-                drop(Box::from_raw(child));
+            release_array_ptr(child);
+        }
+    }
+}
+
+/// Release the owned dictionary array, if this Arrow array has one.
+unsafe fn release_dictionary(private_data: &mut PrivateData) {
+    unsafe {
+        let dictionary = ptr::replace(&raw mut private_data.dictionary, ptr::null_mut());
+        release_array_ptr(dictionary);
+    }
+}
+
+/// Release an ArrowArray pointer allocated for private data.
+unsafe fn release_array_ptr(array: *mut ArrowArray) {
+    unsafe {
+        if !array.is_null() {
+            if let Some(release) = (*array).release {
+                release(array);
             }
+            // Owned arrays are allocated with Box::into_raw in PrivateData, so the release callback
+            // must also reclaim the ArrowArray allocation itself.
+            drop(Box::from_raw(array));
         }
     }
 }
@@ -357,22 +1221,34 @@ mod tests {
     use vortex::array::IntoArray;
     use vortex::array::arrays::BoolArray;
     use vortex::array::arrays::DecimalArray;
+    use vortex::array::arrays::DictArray;
+    use vortex::array::arrays::FixedSizeListArray;
+    use vortex::array::arrays::ListArray;
+    use vortex::array::arrays::ListViewArray;
     use vortex::array::arrays::NullArray;
     use vortex::array::arrays::PrimitiveArray;
     use vortex::array::arrays::StructArray;
     use vortex::array::arrays::TemporalArray;
     use vortex::array::arrays::VarBinViewArray;
+    use vortex::array::arrays::primitive::PrimitiveArrayExt;
     use vortex::array::arrays::varbinview::BinaryView;
+    use vortex::array::buffer::BufferHandle;
     use vortex::array::validity::Validity;
+    use vortex::buffer::BitBuffer;
     use vortex::buffer::Buffer;
     use vortex::buffer::ByteBuffer;
     use vortex::dtype::DType;
     use vortex::dtype::DecimalDType;
     use vortex::dtype::FieldNames;
+    use vortex::dtype::NativeDecimalType;
+    use vortex::dtype::NativePType;
     use vortex::dtype::Nullability;
+    use vortex::dtype::PType;
     use vortex::dtype::half::f16;
+    use vortex::dtype::i256;
     use vortex::error::VortexExpect;
     use vortex::error::VortexResult;
+    use vortex::error::vortex_bail;
     use vortex::extension::datetime::TimeUnit;
     use vortex::session::VortexSession;
 
@@ -382,6 +1258,9 @@ mod tests {
     use crate::arrow::ArrowDeviceArray;
     use crate::arrow::DeviceArrayExt;
     use crate::arrow::PrivateData;
+    use crate::arrow::canonical::export_arrow_validity_buffer;
+    use crate::arrow::canonical::repack_arrow_validity_buffer;
+    use crate::device_buffer::cuda_backing_allocation;
     use crate::session::CudaSession;
 
     unsafe fn release_exported_array(array: *mut ArrowArray) {
@@ -516,8 +1395,139 @@ mod tests {
         (array, buffer_lengths)
     }
 
-    // Build a nested struct fixture with an out-of-line string-view value.
-    fn nested_struct_array() -> ArrayRef {
+    async fn primitive_on_device<T: NativePType>(
+        values: impl IntoIterator<Item = T>,
+        ctx: &mut CudaExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let primitive = PrimitiveArray::from_iter(values);
+        let handle = ctx
+            .ensure_on_device(primitive.buffer_handle().clone())
+            .await?;
+        Ok(
+            PrimitiveArray::from_buffer_handle(handle, T::PTYPE, Validity::NonNullable)
+                .into_array(),
+        )
+    }
+
+    async fn primitive_i32_on_device(
+        values: impl IntoIterator<Item = i32>,
+        ctx: &mut CudaExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        primitive_on_device(values, ctx).await
+    }
+
+    #[expect(clippy::cast_possible_truncation)]
+    async fn integer_array_on_device(
+        ptype: PType,
+        values: &[i64],
+        ctx: &mut CudaExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        match ptype {
+            PType::U8 => primitive_on_device(values.iter().map(|&value| value as u8), ctx).await,
+            PType::U16 => primitive_on_device(values.iter().map(|&value| value as u16), ctx).await,
+            PType::U32 => primitive_on_device(values.iter().map(|&value| value as u32), ctx).await,
+            PType::U64 => primitive_on_device(values.iter().map(|&value| value as u64), ctx).await,
+            PType::I8 => primitive_on_device(values.iter().map(|&value| value as i8), ctx).await,
+            PType::I16 => primitive_on_device(values.iter().map(|&value| value as i16), ctx).await,
+            PType::I32 => primitive_on_device(values.iter().map(|&value| value as i32), ctx).await,
+            PType::I64 => primitive_on_device(values.iter().copied(), ctx).await,
+            ptype => vortex_bail!("test helper only supports integer PTypes, got {ptype}"),
+        }
+    }
+
+    async fn nullable_primitive_i32_on_device(
+        values: impl IntoIterator<Item = Option<i32>>,
+        ctx: &mut CudaExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let primitive = PrimitiveArray::from_option_iter(values);
+        let handle = ctx
+            .ensure_on_device(primitive.buffer_handle().clone())
+            .await?;
+        Ok(
+            PrimitiveArray::from_buffer_handle(handle, PType::I32, primitive.validity()?)
+                .into_array(),
+        )
+    }
+
+    fn private_data_buffer_i32_values(
+        array: &ArrowArray,
+        buffer_idx: usize,
+    ) -> VortexResult<Vec<i32>> {
+        let private_data = unsafe { &*array.private_data.cast::<PrivateData>() };
+        let buffer = private_data.buffers[buffer_idx]
+            .as_ref()
+            .vortex_expect("buffer should be present");
+        Ok(Buffer::<i32>::from_byte_buffer(buffer.to_host_sync())
+            .iter()
+            .copied()
+            .collect())
+    }
+
+    fn private_data_buffer_i16_values(
+        array: &ArrowArray,
+        buffer_idx: usize,
+    ) -> VortexResult<Vec<i16>> {
+        let private_data = unsafe { &*array.private_data.cast::<PrivateData>() };
+        let buffer = private_data.buffers[buffer_idx]
+            .as_ref()
+            .vortex_expect("buffer should be present");
+        Ok(Buffer::<i16>::from_byte_buffer(buffer.to_host_sync())
+            .iter()
+            .copied()
+            .collect())
+    }
+
+    fn private_data_buffer_bytes(
+        array: &ArrowArray,
+        buffer_idx: usize,
+    ) -> VortexResult<ByteBuffer> {
+        let private_data = unsafe { &*array.private_data.cast::<PrivateData>() };
+        let buffer = private_data.buffers[buffer_idx]
+            .as_ref()
+            .vortex_expect("buffer should be present");
+        Ok(buffer.to_host_sync())
+    }
+
+    // Assert Arrow Binary export uses the standard null bitmap, i32 offsets, and values layout.
+    fn assert_binary_layout(
+        array: &ArrowArray,
+        expected_len: i64,
+        expected_null_count: i64,
+        expected_offsets: &[i32],
+        expected_values: &[u8],
+    ) -> VortexResult<()> {
+        assert_eq!(array.length, expected_len);
+        assert_eq!(array.null_count, expected_null_count);
+        assert_eq!(array.offset, 0);
+        assert_eq!(array.n_buffers, 3);
+        assert_eq!(array.n_children, 0);
+        assert!(array.release.is_some());
+        assert!(!array.private_data.is_null());
+
+        let buffers =
+            unsafe { std::slice::from_raw_parts(array.buffers, usize::try_from(array.n_buffers)?) };
+        assert_eq!(buffers[0].is_null(), expected_null_count == 0);
+        assert!(!buffers[1].is_null());
+        assert!(!buffers[2].is_null());
+        assert_eq!(private_data_buffer_i32_values(array, 1)?, expected_offsets);
+        assert_eq!(
+            private_data_buffer_bytes(array, 2)?.as_ref(),
+            expected_values
+        );
+
+        Ok(())
+    }
+
+    fn assert_exported_decimal_values<T: NativeDecimalType>(
+        value_buffer: &BufferHandle,
+        expected: &[T],
+    ) {
+        let values = Buffer::<T>::from_byte_buffer(value_buffer.to_host_sync());
+        assert_eq!(values.as_slice(), expected);
+    }
+
+    // Build a nested struct fixture with an out-of-line string-view value.
+    fn nested_struct_array() -> ArrayRef {
         let nested = StructArray::new(
             FieldNames::from_iter(["b", "c"]),
             vec![
@@ -570,171 +1580,1126 @@ mod tests {
         DataType::Float64
     )]
     #[crate::test]
-    async fn test_export_primitive(
-        #[case] array: ArrayRef,
-        #[case] expected_len: i64,
-        #[case] expected_data_type: DataType,
-    ) -> VortexResult<()> {
+    async fn test_export_primitive(
+        #[case] array: ArrayRef,
+        #[case] expected_len: i64,
+        #[case] expected_data_type: DataType,
+    ) -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let mut exported = array.export_device_array_with_schema(&mut ctx).await?;
+
+        let field = Field::try_from(&exported.schema)?;
+        assert_eq!(field, Field::new("", expected_data_type, false));
+        assert_eq!(exported.array.array.length, expected_len);
+        assert_eq!(exported.array.array.null_count, 0);
+        assert_eq!(exported.array.array.offset, 0);
+        assert_eq!(exported.array.array.n_buffers, 2);
+        assert_eq!(exported.array.array.n_children, 0);
+        assert!(exported.array.array.release.is_some());
+        assert_eq!(exported.array.device_type, ARROW_DEVICE_CUDA);
+
+        unsafe { release_exported_array(&raw mut exported.array.array) };
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_export_null() -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let array = NullArray::new(7).into_array();
+        let mut device_array = array.export_device_array(&mut ctx).await?;
+
+        assert_eq!(device_array.array.length, 7);
+        assert_eq!(device_array.array.null_count, 7);
+        assert_eq!(device_array.device_type, ARROW_DEVICE_CUDA);
+
+        unsafe { release_exported_array(&raw mut device_array.array) };
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_export_dictionary() -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let out_of_line = "a dictionary value stored out-of-line";
+        let array = DictArray::try_new(
+            PrimitiveArray::from_option_iter([Some(0u8), None, Some(1), Some(0)]).into_array(),
+            VarBinViewArray::from_iter_str(["alpha", out_of_line]).into_array(),
+        )?
+        .into_array();
+        let mut exported = array.export_device_array_with_schema(&mut ctx).await?;
+
+        let field = Field::try_from(&exported.schema)?;
+        assert_eq!(
+            field,
+            Field::new(
+                "",
+                DataType::Dictionary(Box::new(DataType::Int16), Box::new(DataType::Utf8View)),
+                true,
+            )
+        );
+        assert_eq!(exported.array.array.length, 4);
+        assert_eq!(exported.array.array.null_count, 1);
+        assert_eq!(exported.array.array.n_buffers, 2);
+        assert_eq!(exported.array.array.n_children, 0);
+        assert!(!exported.array.array.dictionary.is_null());
+        assert_eq!(exported.array.device_type, ARROW_DEVICE_CUDA);
+
+        let private_data = unsafe { &*exported.array.array.private_data.cast::<PrivateData>() };
+        assert_eq!(
+            private_data.buffers[1]
+                .as_ref()
+                .vortex_expect("codes buffer should be present")
+                .len(),
+            4 * size_of::<i16>()
+        );
+
+        let dictionary = unsafe { &*exported.array.array.dictionary };
+        assert_varbinview_layout(dictionary, 2, 0, &[out_of_line.len()])?;
+
+        unsafe { release_exported_array(&raw mut exported.array.array) };
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_export_struct_preserves_dictionary_child() -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let dictionary = DictArray::try_new(
+            PrimitiveArray::from_option_iter([Some(0u8), None, Some(1)]).into_array(),
+            VarBinViewArray::from_iter_str(["alpha", "beta"]).into_array(),
+        )?
+        .into_array();
+        let array = StructArray::new(
+            FieldNames::from_iter(["dict"]),
+            vec![dictionary],
+            3,
+            Validity::NonNullable,
+        )
+        .into_array();
+        let mut exported = array.export_device_array_with_schema(&mut ctx).await?;
+
+        let field = Field::try_from(&exported.schema)?;
+        assert_eq!(
+            field,
+            Field::new(
+                "",
+                DataType::Struct(Fields::from(vec![Field::new(
+                    "dict",
+                    DataType::Dictionary(Box::new(DataType::Int16), Box::new(DataType::Utf8View)),
+                    true,
+                )])),
+                false,
+            )
+        );
+        assert_eq!(exported.array.array.n_children, 1);
+        let children = unsafe { std::slice::from_raw_parts(exported.array.array.children, 1) };
+        let dict_child = unsafe { &*children[0] };
+        assert!(!dict_child.dictionary.is_null());
+        assert_eq!(dict_child.null_count, 1);
+
+        unsafe { release_exported_array(&raw mut exported.array.array) };
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_export_dictionary_with_nullable_values() -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let array = DictArray::try_new(
+            PrimitiveArray::from_iter([0u8, 1, 0]).into_array(),
+            PrimitiveArray::from_option_iter([Some(10i32), None]).into_array(),
+        )?
+        .into_array();
+        let mut exported = array.export_device_array_with_schema(&mut ctx).await?;
+
+        let field = Field::try_from(&exported.schema)?;
+        assert_eq!(
+            field,
+            Field::new(
+                "",
+                DataType::Dictionary(Box::new(DataType::Int16), Box::new(DataType::Int32)),
+                true,
+            )
+        );
+        assert_eq!(exported.array.array.null_count, 0);
+        assert_eq!(
+            private_data_buffer_i16_values(&exported.array.array, 1)?,
+            [0, 1, 0]
+        );
+        let dictionary = unsafe { &*exported.array.array.dictionary };
+        assert_eq!(dictionary.null_count, 1);
+        assert_eq!(private_data_buffer_i32_values(dictionary, 1)?.len(), 2);
+
+        unsafe { release_exported_array(&raw mut exported.array.array) };
+        Ok(())
+    }
+
+    async fn assert_exported_decimal<T: NativeDecimalType>(
+        array: ArrayRef,
+        expected_data_type: DataType,
+        expected_values: Vec<T>,
+    ) -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let mut exported = array.export_device_array_with_schema(&mut ctx).await?;
+
+        let field = Field::try_from(&exported.schema)?;
+        assert_eq!(field, Field::new("", expected_data_type, false));
+        assert_eq!(
+            exported.array.array.length,
+            i64::try_from(expected_values.len())?
+        );
+        assert_eq!(exported.array.array.null_count, 0);
+        assert_eq!(exported.array.array.n_buffers, 2);
+        assert_eq!(exported.array.array.n_children, 0);
+        assert!(exported.array.array.release.is_some());
+        assert_eq!(exported.array.device_type, ARROW_DEVICE_CUDA);
+
+        let private_data = unsafe { &*exported.array.array.private_data.cast::<PrivateData>() };
+        let value_buffer = private_data.buffers[1]
+            .as_ref()
+            .vortex_expect("value buffer should be present");
+        assert_eq!(value_buffer.len(), expected_values.len() * size_of::<T>());
+        assert_exported_decimal_values(value_buffer, &expected_values);
+
+        unsafe { release_exported_array(&raw mut exported.array.array) };
+        Ok(())
+    }
+
+    #[rstest]
+    #[case::i8(
+        DecimalArray::from_iter([1i8, -2, 3], DecimalDType::new(2, 1)).into_array(),
+        DataType::Decimal32(2, 1),
+        vec![1i32, -2, 3]
+    )]
+    #[case::i16(
+        DecimalArray::from_iter([100i16, -200, 300], DecimalDType::new(4, 2)).into_array(),
+        DataType::Decimal32(4, 2),
+        vec![100i32, -200, 300]
+    )]
+    #[case::i32(
+        DecimalArray::from_iter([10_000i32, -20_000, 30_000], DecimalDType::new(9, 2)).into_array(),
+        DataType::Decimal32(9, 2),
+        vec![10_000i32, -20_000, 30_000]
+    )]
+    #[crate::test]
+    async fn test_export_decimal32(
+        #[case] array: ArrayRef,
+        #[case] expected_data_type: DataType,
+        #[case] expected_values: Vec<i32>,
+    ) -> VortexResult<()> {
+        assert_exported_decimal(array, expected_data_type, expected_values).await
+    }
+
+    #[rstest]
+    #[case::i32(
+        DecimalArray::from_iter([1_000_000i32, -2_000_000, 3_000_000], DecimalDType::new(10, 2)).into_array(),
+        DataType::Decimal64(10, 2),
+        vec![1_000_000i64, -2_000_000, 3_000_000]
+    )]
+    #[case::i32_boundary(
+        DecimalArray::from_iter([i32::MIN, -1i32, 0, 1, i32::MAX], DecimalDType::new(10, 0)).into_array(),
+        DataType::Decimal64(10, 0),
+        vec![i32::MIN as i64, -1, 0, 1, i32::MAX as i64]
+    )]
+    #[case::i64(
+        DecimalArray::from_iter([1_000_000i64, -2_000_000, 3_000_000], DecimalDType::new(18, 2)).into_array(),
+        DataType::Decimal64(18, 2),
+        vec![1_000_000i64, -2_000_000, 3_000_000]
+    )]
+    #[crate::test]
+    async fn test_export_decimal64(
+        #[case] array: ArrayRef,
+        #[case] expected_data_type: DataType,
+        #[case] expected_values: Vec<i64>,
+    ) -> VortexResult<()> {
+        assert_exported_decimal(array, expected_data_type, expected_values).await
+    }
+
+    #[rstest]
+    #[case::i64_boundary(
+        DecimalArray::from_iter([i64::MIN, -1i64, 0, 1, i64::MAX], DecimalDType::new(19, 0)).into_array(),
+        DataType::Decimal128(19, 0),
+        vec![i64::MIN as i128, -1, 0, 1, i64::MAX as i128]
+    )]
+    #[case::i128(
+        DecimalArray::from_iter([1i128, -2, 3], DecimalDType::new(38, 2)).into_array(),
+        DataType::Decimal128(38, 2),
+        vec![1i128, -2, 3]
+    )]
+    #[crate::test]
+    async fn test_export_decimal128(
+        #[case] array: ArrayRef,
+        #[case] expected_data_type: DataType,
+        #[case] expected_values: Vec<i128>,
+    ) -> VortexResult<()> {
+        assert_exported_decimal(array, expected_data_type, expected_values).await
+    }
+
+    #[crate::test]
+    async fn test_export_empty_decimal() -> VortexResult<()> {
+        assert_exported_decimal(
+            DecimalArray::new(
+                Buffer::<i32>::empty(),
+                DecimalDType::new(9, 2),
+                Validity::NonNullable,
+            )
+            .into_array(),
+            DataType::Decimal32(9, 2),
+            Vec::<i32>::new(),
+        )
+        .await
+    }
+
+    #[crate::test]
+    async fn test_export_empty_decimal_widening() -> VortexResult<()> {
+        assert_exported_decimal(
+            DecimalArray::new(
+                Buffer::<i8>::empty(),
+                DecimalDType::new(9, 2),
+                Validity::NonNullable,
+            )
+            .into_array(),
+            DataType::Decimal32(9, 2),
+            Vec::<i32>::new(),
+        )
+        .await
+    }
+
+    #[crate::test]
+    async fn test_export_decimal_narrowing_errors() -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+        let array = DecimalArray::from_iter([i256::from_parts(0, 1)], DecimalDType::new(38, 0))
+            .into_array();
+
+        let err = array
+            .export_device_array_with_schema(&mut ctx)
+            .await
+            .unwrap_err();
+        assert!(err.to_string().contains("narrowing would require"));
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_export_decimal_narrowing_from_arrow_import() -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+        let array = DecimalArray::from_iter([0i128, 1, -2], DecimalDType::new(10, 2)).into_array();
+
+        let err = array
+            .export_device_array_with_schema(&mut ctx)
+            .await
+            .unwrap_err();
+        assert!(err.to_string().contains("narrowing would require"));
+        Ok(())
+    }
+
+    #[rstest]
+    #[case::i64(
+        DecimalArray::from_iter([i64::MIN, -1i64, 1, i64::MAX], DecimalDType::new(39, 0)).into_array(),
+        DataType::Decimal256(39, 0),
+        vec![i256::from_i128(i64::MIN as i128), i256::from_i128(-1), i256::from_i128(1), i256::from_i128(i64::MAX as i128)]
+    )]
+    #[case::i128(
+        DecimalArray::from_iter([1i128, -2, 3], DecimalDType::new(39, 2)).into_array(),
+        DataType::Decimal256(39, 2),
+        vec![i256::from_i128(1), i256::from_i128(-2), i256::from_i128(3)]
+    )]
+    #[case::i256(
+        DecimalArray::from_iter(
+            [i256::from_i128(10), i256::from_i128(-20), i256::from_i128(30)],
+            DecimalDType::new(76, 2),
+        )
+        .into_array(),
+        DataType::Decimal256(76, 2),
+        vec![i256::from_i128(10), i256::from_i128(-20), i256::from_i128(30)]
+    )]
+    #[crate::test]
+    async fn test_export_decimal256(
+        #[case] array: ArrayRef,
+        #[case] expected_data_type: DataType,
+        #[case] expected_values: Vec<i256>,
+    ) -> VortexResult<()> {
+        assert_exported_decimal(array, expected_data_type, expected_values).await
+    }
+
+    #[crate::test]
+    async fn test_export_temporal() -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let array = TemporalArray::new_date(
+            PrimitiveArray::from_iter([100i32, 200, 300]).into_array(),
+            TimeUnit::Days,
+        )
+        .into_array();
+        let mut device_array = array.export_device_array(&mut ctx).await?;
+
+        assert_eq!(device_array.array.length, 3);
+        assert_eq!(device_array.array.null_count, 0);
+        assert_eq!(device_array.array.n_buffers, 2);
+        assert_eq!(device_array.array.n_children, 0);
+        assert!(device_array.array.release.is_some());
+        assert_eq!(device_array.device_type, ARROW_DEVICE_CUDA);
+
+        unsafe { release_exported_array(&raw mut device_array.array) };
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_export_bool() -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let array = BoolArray::from_iter([true, false, true]).into_array();
+        let mut device_array = array.export_device_array(&mut ctx).await?;
+
+        assert_eq!(device_array.array.length, 3);
+        assert_eq!(device_array.array.null_count, 0);
+        assert_eq!(device_array.array.n_buffers, 2);
+        assert_eq!(device_array.array.n_children, 0);
+        assert!(device_array.array.release.is_some());
+        assert_eq!(device_array.device_type, ARROW_DEVICE_CUDA);
+
+        unsafe { release_exported_array(&raw mut device_array.array) };
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_export_varbinview() -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let out_of_line = "this is a longer string for out-of-line storage";
+        let array = VarBinViewArray::from_iter_str(["hello", "world", out_of_line]).into_array();
+        let mut device_array = array.export_device_array(&mut ctx).await?;
+
+        assert_varbinview_layout(&device_array.array, 3, 0, &[out_of_line.len()])?;
+        assert_eq!(device_array.device_type, ARROW_DEVICE_CUDA);
+
+        unsafe { release_exported_array(&raw mut device_array.array) };
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_export_binary_inline_outline_values() -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let out_of_line = b"this binary payload is longer than twelve bytes";
+        let array = VarBinViewArray::from_iter_nullable_bin([
+            Some(b"" as &[u8]),
+            Some(b"\x00\xff\xfe"),
+            None,
+            Some(b"short"),
+            Some(out_of_line),
+        ])
+        .into_array();
+        let mut exported = array.export_device_array_with_schema(&mut ctx).await?;
+
+        let field = Field::try_from(&exported.schema)?;
+        assert_eq!(field, Field::new("", DataType::Binary, true));
+        assert_binary_layout(
+            &exported.array.array,
+            5,
+            1,
+            &[0, 0, 3, 3, 8, i32::try_from(8 + out_of_line.len())?],
+            &[b"\x00\xff\xfe".as_slice(), b"short", out_of_line].concat(),
+        )?;
+        assert_eq!(exported.array.device_type, ARROW_DEVICE_CUDA);
+
+        unsafe { release_exported_array(&raw mut exported.array.array) };
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_export_binary_empty_and_all_null() -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let empty = VarBinViewArray::from_iter_nullable_bin(std::iter::empty::<Option<&[u8]>>())
+            .into_array();
+        let mut exported = empty.export_device_array_with_schema(&mut ctx).await?;
+        let field = Field::try_from(&exported.schema)?;
+        assert_eq!(field, Field::new("", DataType::Binary, true));
+        assert_binary_layout(&exported.array.array, 0, 0, &[0], b"")?;
+        assert_eq!(exported.array.device_type, ARROW_DEVICE_CUDA);
+        unsafe { release_exported_array(&raw mut exported.array.array) };
+
+        let all_null =
+            VarBinViewArray::from_iter_nullable_bin([None::<&[u8]>, None::<&[u8]>]).into_array();
+        let mut exported = all_null.export_device_array_with_schema(&mut ctx).await?;
+        let field = Field::try_from(&exported.schema)?;
+        assert_eq!(field, Field::new("", DataType::Binary, true));
+        assert_binary_layout(&exported.array.array, 2, 2, &[0, 0, 0], b"")?;
+        assert_eq!(exported.array.device_type, ARROW_DEVICE_CUDA);
+        unsafe { release_exported_array(&raw mut exported.array.array) };
+
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_export_binary_invalid_data_buffer_ref_errors() -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let view = BinaryView::make_view(b"this references a missing data buffer", 0, 0);
+        let array = VarBinViewArray::new_handle(
+            BufferHandle::new_host(Buffer::from_iter([view]).into_byte_buffer()),
+            Arc::from([]),
+            DType::Binary(Nullability::NonNullable),
+            Validity::NonNullable,
+        )
+        .into_array();
+
+        let err = array
+            .export_device_array_with_schema(&mut ctx)
+            .await
+            .expect_err("missing binary data buffer should fail");
+        assert!(
+            err.to_string()
+                .contains("a view references an invalid data buffer")
+        );
+
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_export_binary_i32_offset_overflow_errors() -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let view = BinaryView::new_ref(i32::MAX as u32 + 1, [0; 4], 0, 0);
+        let array = VarBinViewArray::new_handle(
+            BufferHandle::new_host(Buffer::from_iter([view]).into_byte_buffer()),
+            Arc::from([]),
+            DType::Binary(Nullability::NonNullable),
+            Validity::NonNullable,
+        )
+        .into_array();
+
+        let err = array
+            .export_device_array_with_schema(&mut ctx)
+            .await
+            .expect_err("oversized binary value should fail Arrow Binary export");
+        assert!(
+            err.to_string()
+                .contains("offsets exceed i32 range required by Arrow Binary")
+        );
+
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_export_list() -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let array = ListArray::try_new(
+            PrimitiveArray::from_iter(0i32..5).into_array(),
+            PrimitiveArray::from_iter([0i32, 2, 2, 5]).into_array(),
+            Validity::NonNullable,
+        )?
+        .into_array();
+        let mut exported = array.export_device_array_with_schema(&mut ctx).await?;
+
+        let field = Field::try_from(&exported.schema)?;
+        assert_eq!(
+            field,
+            Field::new_list(
+                "",
+                Field::new(Field::LIST_FIELD_DEFAULT_NAME, DataType::Int32, false),
+                false,
+            )
+        );
+        assert_eq!(exported.array.array.length, 3);
+        assert_eq!(exported.array.array.null_count, 0);
+        assert_eq!(exported.array.array.n_buffers, 2);
+        let buffers = unsafe { std::slice::from_raw_parts(exported.array.array.buffers, 2) };
+        assert!(buffers[0].is_null());
+        assert!(!buffers[1].is_null());
+        assert_eq!(exported.array.array.n_children, 1);
+        let children = unsafe { std::slice::from_raw_parts(exported.array.array.children, 1) };
+        let elements = unsafe { &*children[0] };
+        assert_eq!(elements.length, 5);
+        assert_eq!(elements.n_buffers, 2);
+        assert_eq!(exported.array.device_type, ARROW_DEVICE_CUDA);
+
+        unsafe { release_exported_array(&raw mut exported.array.array) };
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_export_host_contiguous_list_view() -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let array = ListViewArray::new(
+            PrimitiveArray::from_iter(0i32..5).into_array(),
+            PrimitiveArray::from_iter([0i32, 2, 2]).into_array(),
+            PrimitiveArray::from_iter([2i32, 0, 3]).into_array(),
+            Validity::NonNullable,
+        )
+        .into_array();
+        let mut exported = array.export_device_array_with_schema(&mut ctx).await?;
+
+        assert_eq!(exported.array.array.length, 3);
+        assert_eq!(exported.array.array.n_buffers, 2);
+        assert_eq!(
+            private_data_buffer_i32_values(&exported.array.array, 1)?,
+            [0, 2, 2, 5]
+        );
+        assert_eq!(exported.array.device_type, ARROW_DEVICE_CUDA);
+
+        unsafe { release_exported_array(&raw mut exported.array.array) };
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_export_host_non_contiguous_nested_list_view_falls_back_to_cpu() -> VortexResult<()>
+    {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let elements = StructArray::new(
+            FieldNames::from_iter(["x"]),
+            vec![PrimitiveArray::from_iter(0i32..4).into_array()],
+            4,
+            Validity::NonNullable,
+        )
+        .into_array();
+        let array = ListViewArray::new(
+            elements,
+            PrimitiveArray::from_iter([0i32, 1]).into_array(),
+            PrimitiveArray::from_iter([3i32, 2]).into_array(),
+            Validity::NonNullable,
+        )
+        .into_array();
+        let mut exported = array.export_device_array_with_schema(&mut ctx).await?;
+
+        assert_eq!(exported.array.array.length, 2);
+        assert_eq!(
+            private_data_buffer_i32_values(&exported.array.array, 1)?,
+            [0, 3, 5]
+        );
+        let list_children = unsafe { std::slice::from_raw_parts(exported.array.array.children, 1) };
+        let struct_child = unsafe { &*list_children[0] };
+        assert_eq!(struct_child.length, 5);
+        let struct_children = unsafe { std::slice::from_raw_parts(struct_child.children, 1) };
+        let field_child = unsafe { &*struct_children[0] };
+        assert_eq!(
+            private_data_buffer_i32_values(field_child, 1)?,
+            [0, 1, 2, 1, 2]
+        );
+        assert_eq!(exported.array.device_type, ARROW_DEVICE_CUDA);
+
+        unsafe { release_exported_array(&raw mut exported.array.array) };
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_export_host_non_contiguous_dictionary_list_view_schema_matches_rebuilt_child()
+    -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let elements = DictArray::try_new(
+            PrimitiveArray::from_option_iter([Some(0u8), None, Some(1), Some(2)]).into_array(),
+            PrimitiveArray::from_iter([10i32, 20, 30]).into_array(),
+        )?
+        .into_array();
+        let array = ListViewArray::new(
+            elements,
+            PrimitiveArray::from_iter([0i32, 1]).into_array(),
+            PrimitiveArray::from_iter([3i32, 2]).into_array(),
+            Validity::NonNullable,
+        )
+        .into_array();
+        let mut exported = array.export_device_array_with_schema(&mut ctx).await?;
+
+        let field = Field::try_from(&exported.schema)?;
+        assert_eq!(
+            field,
+            Field::new_list(
+                "",
+                Field::new(
+                    Field::LIST_FIELD_DEFAULT_NAME,
+                    DataType::Dictionary(
+                        Box::new(DataType::Int64),
+                        Box::new(DataType::Dictionary(
+                            Box::new(DataType::Int16),
+                            Box::new(DataType::Int32),
+                        )),
+                    ),
+                    true,
+                ),
+                false,
+            )
+        );
+        assert_eq!(
+            private_data_buffer_i32_values(&exported.array.array, 1)?,
+            [0, 3, 5]
+        );
+        let list_children = unsafe { std::slice::from_raw_parts(exported.array.array.children, 1) };
+        let dict_child = unsafe { &*list_children[0] };
+        assert!(!dict_child.dictionary.is_null());
+        assert_eq!(dict_child.length, 5);
+        assert_eq!(dict_child.n_buffers, 2);
+        let nested_dict = unsafe { &*dict_child.dictionary };
+        assert!(!nested_dict.dictionary.is_null());
+
+        unsafe { release_exported_array(&raw mut exported.array.array) };
+        Ok(())
+    }
+
+    // Regression test: with an average list size >= 128 the host list-view rebuild picks its
+    // list-by-list strategy, which may canonicalize Dict elements. The schema must describe the
+    // rebuilt child layout.
+    #[crate::test]
+    async fn test_export_host_large_lists_dictionary_list_view_schema_matches_rebuilt_child()
+    -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let elements = DictArray::try_new(
+            PrimitiveArray::from_option_iter(
+                (0..256u32).map(|i| (i % 5 != 0).then_some((i % 3) as u8)),
+            )
+            .into_array(),
+            PrimitiveArray::from_iter([10i32, 20, 30]).into_array(),
+        )?
+        .into_array();
+        let array = ListViewArray::new(
+            elements,
+            PrimitiveArray::from_iter([128i32, 0]).into_array(),
+            PrimitiveArray::from_iter([128i32, 128]).into_array(),
+            Validity::NonNullable,
+        )
+        .into_array();
+        let mut exported = array.export_device_array_with_schema(&mut ctx).await?;
+
+        let field = Field::try_from(&exported.schema)?;
+        assert_eq!(
+            field,
+            Field::new_list(
+                "",
+                Field::new(Field::LIST_FIELD_DEFAULT_NAME, DataType::Int32, true),
+                false,
+            )
+        );
+        assert_eq!(
+            private_data_buffer_i32_values(&exported.array.array, 1)?,
+            [0, 128, 256]
+        );
+        let list_children = unsafe { std::slice::from_raw_parts(exported.array.array.children, 1) };
+        let child = unsafe { &*list_children[0] };
+        assert!(child.dictionary.is_null());
+        assert_eq!(child.length, 256);
+        assert_eq!(child.n_buffers, 2);
+
+        unsafe { release_exported_array(&raw mut exported.array.array) };
+        Ok(())
+    }
+
+    #[rstest]
+    #[case::i32_i32(PType::I32, PType::I32)]
+    #[case::u32_u16(PType::U32, PType::U16)]
+    #[case::i64_u8(PType::I64, PType::U8)]
+    #[case::u64_i16(PType::U64, PType::I16)]
+    #[crate::test]
+    async fn test_export_device_contiguous_list_view(
+        #[case] offsets_ptype: PType,
+        #[case] sizes_ptype: PType,
+    ) -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let elements = primitive_i32_on_device(0..5, &mut ctx).await?;
+        let offsets = integer_array_on_device(offsets_ptype, &[0, 2, 2], &mut ctx).await?;
+        let sizes = integer_array_on_device(sizes_ptype, &[2, 0, 3], &mut ctx).await?;
+        let array =
+            ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
+        let mut exported = array.export_device_array_with_schema(&mut ctx).await?;
+
+        let field = Field::try_from(&exported.schema)?;
+        assert_eq!(
+            field,
+            Field::new_list(
+                "",
+                Field::new(Field::LIST_FIELD_DEFAULT_NAME, DataType::Int32, false),
+                false,
+            )
+        );
+        assert_eq!(exported.array.array.length, 3);
+        assert_eq!(exported.array.array.n_buffers, 2);
+        assert_eq!(
+            private_data_buffer_i32_values(&exported.array.array, 1)?,
+            [0, 2, 2, 5]
+        );
+        assert_eq!(exported.array.device_type, ARROW_DEVICE_CUDA);
+
+        unsafe { release_exported_array(&raw mut exported.array.array) };
+        Ok(())
+    }
+
+    #[rstest]
+    #[case::utf8(
+        multi_buffer_varbinview(DType::Utf8(Nullability::NonNullable)),
+        DataType::Utf8View
+    )]
+    #[case::binary(
+        multi_buffer_varbinview(DType::Binary(Nullability::NonNullable)),
+        DataType::Binary
+    )]
+    #[crate::test]
+    async fn test_export_varbinview_multiple_variadic_buffers(
+        #[case] fixture: (ArrayRef, [usize; 2]),
+        #[case] expected_data_type: DataType,
+    ) -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let (array, expected_data_buffer_lengths) = fixture;
+        let mut exported = array.export_device_array_with_schema(&mut ctx).await?;
+
+        let field = Field::try_from(&exported.schema)?;
+        let is_binary = expected_data_type == DataType::Binary;
+        assert_eq!(field, Field::new("", expected_data_type, false));
+        if is_binary {
+            assert_binary_layout(
+                &exported.array.array,
+                3,
+                0,
+                &[0, 6, 36, 67],
+                b"inlinefirst value stored out-of-linesecond value stored out-of-line",
+            )?;
+        } else {
+            assert_varbinview_layout(&exported.array.array, 3, 0, &expected_data_buffer_lengths)?;
+        }
+        assert_eq!(exported.array.device_type, ARROW_DEVICE_CUDA);
+
+        unsafe { release_exported_array(&raw mut exported.array.array) };
+        Ok(())
+    }
+
+    #[rstest]
+    #[case::i64(PrimitiveArray::from_iter([0i64, 2, 2, 5]).into_array())]
+    #[case::u64(PrimitiveArray::from_iter([0u64, 2, 2, 5]).into_array())]
+    #[crate::test]
+    async fn test_export_list_with_non_i32_offsets(#[case] offsets: ArrayRef) -> VortexResult<()> {
         let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
 
+        let array = ListArray::try_new(
+            PrimitiveArray::from_iter(0i32..5).into_array(),
+            offsets,
+            Validity::NonNullable,
+        )?
+        .into_array();
         let mut exported = array.export_device_array_with_schema(&mut ctx).await?;
 
-        let field = Field::try_from(&exported.schema)?;
-        assert_eq!(field, Field::new("", expected_data_type, false));
-        assert_eq!(exported.array.array.length, expected_len);
-        assert_eq!(exported.array.array.null_count, 0);
-        assert_eq!(exported.array.array.offset, 0);
+        assert_eq!(exported.array.array.length, 3);
         assert_eq!(exported.array.array.n_buffers, 2);
-        assert_eq!(exported.array.array.n_children, 0);
-        assert!(exported.array.array.release.is_some());
-        assert_eq!(exported.array.device_type, ARROW_DEVICE_CUDA);
+        assert_eq!(
+            private_data_buffer_i32_values(&exported.array.array, 1)?,
+            [0, 2, 2, 5]
+        );
 
         unsafe { release_exported_array(&raw mut exported.array.array) };
         Ok(())
     }
 
+    #[rstest]
+    #[case::i32_i32(PType::I32, PType::I32)]
+    #[case::u32_u16(PType::U32, PType::U16)]
+    #[case::i64_u8(PType::I64, PType::U8)]
+    #[case::u64_i16(PType::U64, PType::I16)]
     #[crate::test]
-    async fn test_export_null() -> VortexResult<()> {
+    async fn test_export_device_non_contiguous_primitive_list_view(
+        #[case] offsets_ptype: PType,
+        #[case] sizes_ptype: PType,
+    ) -> VortexResult<()> {
         let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
 
-        let array = NullArray::new(7).into_array();
-        let mut device_array = array.export_device_array(&mut ctx).await?;
+        let elements = primitive_i32_on_device([10, 11, 12, 13, 14], &mut ctx).await?;
+        let offsets = integer_array_on_device(offsets_ptype, &[3, 0, 2], &mut ctx).await?;
+        let sizes = integer_array_on_device(sizes_ptype, &[2, 2, 1], &mut ctx).await?;
+        let array =
+            ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
+        let mut exported = array.export_device_array_with_schema(&mut ctx).await?;
 
-        assert_eq!(device_array.array.length, 7);
-        assert_eq!(device_array.array.null_count, 7);
-        assert_eq!(device_array.device_type, ARROW_DEVICE_CUDA);
+        assert_eq!(exported.array.array.length, 3);
+        assert_eq!(
+            private_data_buffer_i32_values(&exported.array.array, 1)?,
+            [0, 2, 4, 5]
+        );
+        let children = unsafe { std::slice::from_raw_parts(exported.array.array.children, 1) };
+        let elements = unsafe { &*children[0] };
+        assert_eq!(
+            private_data_buffer_i32_values(elements, 1)?,
+            [13, 14, 10, 11, 12]
+        );
+        assert_eq!(exported.array.device_type, ARROW_DEVICE_CUDA);
 
-        unsafe { release_exported_array(&raw mut device_array.array) };
+        unsafe { release_exported_array(&raw mut exported.array.array) };
         Ok(())
     }
 
     #[crate::test]
-    async fn test_export_decimal() -> VortexResult<()> {
+    async fn test_export_device_non_contiguous_dictionary_list_view() -> VortexResult<()> {
         let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
 
-        let array = DecimalArray::from_iter(0i128..5, DecimalDType::new(38, 2)).into_array();
-        let mut device_array = array.export_device_array(&mut ctx).await?;
+        let codes = primitive_on_device([0u8, 1, 2, 0, 1], &mut ctx).await?;
+        let values = PrimitiveArray::from_iter([10i32, 20, 30]).into_array();
+        let elements = DictArray::try_new(codes, values)?.into_array();
+        let offsets = primitive_i32_on_device([3, 0, 2], &mut ctx).await?;
+        let sizes = primitive_i32_on_device([2, 2, 1], &mut ctx).await?;
+        let array =
+            ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
+        let mut exported = array.export_device_array_with_schema(&mut ctx).await?;
 
-        assert_eq!(device_array.array.length, 5);
-        assert_eq!(device_array.array.null_count, 0);
-        assert_eq!(device_array.array.n_buffers, 2);
-        assert_eq!(device_array.array.n_children, 0);
-        assert!(device_array.array.release.is_some());
-        assert_eq!(device_array.device_type, ARROW_DEVICE_CUDA);
+        let field = Field::try_from(&exported.schema)?;
+        assert_eq!(
+            field,
+            Field::new_list(
+                "",
+                Field::new(
+                    Field::LIST_FIELD_DEFAULT_NAME,
+                    DataType::Dictionary(Box::new(DataType::Int16), Box::new(DataType::Int32)),
+                    false,
+                ),
+                false,
+            )
+        );
+        assert_eq!(exported.array.array.length, 3);
+        assert_eq!(
+            private_data_buffer_i32_values(&exported.array.array, 1)?,
+            [0, 2, 4, 5]
+        );
+        let children = unsafe { std::slice::from_raw_parts(exported.array.array.children, 1) };
+        let elements = unsafe { &*children[0] };
+        assert!(!elements.dictionary.is_null());
+        assert_eq!(
+            private_data_buffer_i16_values(elements, 1)?,
+            [0, 1, 0, 1, 2]
+        );
+        let dictionary = unsafe { &*elements.dictionary };
+        assert_eq!(private_data_buffer_i32_values(dictionary, 1)?, [10, 20, 30]);
+        assert_eq!(exported.array.device_type, ARROW_DEVICE_CUDA);
 
-        unsafe { release_exported_array(&raw mut device_array.array) };
+        unsafe { release_exported_array(&raw mut exported.array.array) };
         Ok(())
     }
 
     #[crate::test]
-    async fn test_export_temporal() -> VortexResult<()> {
+    async fn test_export_device_non_contiguous_dictionary_list_view_nullable_values()
+    -> VortexResult<()> {
         let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
 
-        let array = TemporalArray::new_date(
-            PrimitiveArray::from_iter([100i32, 200, 300]).into_array(),
-            TimeUnit::Days,
-        )
-        .into_array();
-        let mut device_array = array.export_device_array(&mut ctx).await?;
+        let codes = primitive_on_device([0u8, 1, 2, 0, 1], &mut ctx).await?;
+        let values = PrimitiveArray::from_option_iter([Some(10i32), None, Some(30)]).into_array();
+        let elements = DictArray::try_new(codes, values)?.into_array();
+        let offsets = primitive_i32_on_device([3, 0, 2], &mut ctx).await?;
+        let sizes = primitive_i32_on_device([2, 2, 1], &mut ctx).await?;
+        let array =
+            ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
+        let mut exported = array.export_device_array_with_schema(&mut ctx).await?;
 
-        assert_eq!(device_array.array.length, 3);
-        assert_eq!(device_array.array.null_count, 0);
-        assert_eq!(device_array.array.n_buffers, 2);
-        assert_eq!(device_array.array.n_children, 0);
-        assert!(device_array.array.release.is_some());
-        assert_eq!(device_array.device_type, ARROW_DEVICE_CUDA);
+        let children = unsafe { std::slice::from_raw_parts(exported.array.array.children, 1) };
+        let elements = unsafe { &*children[0] };
+        assert_eq!(elements.null_count, 0);
+        assert_eq!(
+            private_data_buffer_i16_values(elements, 1)?,
+            [0, 1, 0, 1, 2]
+        );
+        let dictionary = unsafe { &*elements.dictionary };
+        assert_eq!(dictionary.null_count, 1);
 
-        unsafe { release_exported_array(&raw mut device_array.array) };
+        unsafe { release_exported_array(&raw mut exported.array.array) };
         Ok(())
     }
 
     #[crate::test]
-    async fn test_export_bool() -> VortexResult<()> {
+    async fn test_export_device_non_contiguous_dictionary_list_view_nullable_codes_errors()
+    -> VortexResult<()> {
         let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
 
-        let array = BoolArray::from_iter([true, false, true]).into_array();
-        let mut device_array = array.export_device_array(&mut ctx).await?;
-
-        assert_eq!(device_array.array.length, 3);
-        assert_eq!(device_array.array.null_count, 0);
-        assert_eq!(device_array.array.n_buffers, 2);
-        assert_eq!(device_array.array.n_children, 0);
-        assert!(device_array.array.release.is_some());
-        assert_eq!(device_array.device_type, ARROW_DEVICE_CUDA);
+        let codes = PrimitiveArray::from_option_iter([Some(0u8), None, Some(2), Some(0), Some(1)]);
+        let codes_handle = ctx.ensure_on_device(codes.buffer_handle().clone()).await?;
+        let codes = PrimitiveArray::from_buffer_handle(codes_handle, PType::U8, codes.validity()?)
+            .into_array();
+        let values =
+            PrimitiveArray::from_option_iter([Some(10i32), Some(20), Some(30)]).into_array();
+        let elements = DictArray::try_new(codes, values)?.into_array();
+        let offsets = primitive_i32_on_device([3, 0, 2], &mut ctx).await?;
+        let sizes = primitive_i32_on_device([2, 2, 1], &mut ctx).await?;
+        let array =
+            ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
+        let err = match array.export_device_array(&mut ctx).await {
+            Ok(mut exported) => {
+                unsafe { release_exported_array(&raw mut exported.array) };
+                vortex_bail!("nullable dictionary codes should be unsupported")
+            }
+            Err(err) => err,
+        };
 
-        unsafe { release_exported_array(&raw mut device_array.array) };
+        assert!(
+            err.to_string().contains("nullable dictionary codes"),
+            "unexpected error: {err}"
+        );
         Ok(())
     }
 
+    #[rstest]
+    #[case::out_of_bounds(&[3], &[2], "offsets/sizes are invalid")]
+    #[case::negative_offset(&[-1], &[1], "offsets exceed i32 range")]
     #[crate::test]
-    async fn test_export_varbinview() -> VortexResult<()> {
+    async fn test_export_device_invalid_list_view_returns_error(
+        #[case] offsets_values: &[i64],
+        #[case] sizes_values: &[i64],
+        #[case] expected_error: &str,
+    ) -> VortexResult<()> {
         let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
 
-        let out_of_line = "this is a longer string for out-of-line storage";
-        let array = VarBinViewArray::from_iter_str(["hello", "world", out_of_line]).into_array();
-        let mut device_array = array.export_device_array(&mut ctx).await?;
-
-        assert_varbinview_layout(&device_array.array, 3, 0, &[out_of_line.len()])?;
-        assert_eq!(device_array.device_type, ARROW_DEVICE_CUDA);
+        let elements = primitive_i32_on_device(0..4, &mut ctx).await?;
+        let offsets = integer_array_on_device(PType::I32, offsets_values, &mut ctx).await?;
+        let sizes = integer_array_on_device(PType::I32, sizes_values, &mut ctx).await?;
+        let array = unsafe {
+            ListViewArray::new_unchecked(elements, offsets, sizes, Validity::NonNullable)
+        }
+        .into_array();
+        let err = match array.export_device_array(&mut ctx).await {
+            Ok(mut exported) => {
+                unsafe { release_exported_array(&raw mut exported.array) };
+                vortex_bail!("invalid device list view should be unsupported")
+            }
+            Err(err) => err,
+        };
 
-        unsafe { release_exported_array(&raw mut device_array.array) };
+        assert!(
+            err.to_string().contains(expected_error),
+            "unexpected error: {err}"
+        );
         Ok(())
     }
 
     #[crate::test]
-    async fn test_export_binaryview_inline_outline_values() -> VortexResult<()> {
+    async fn test_export_device_non_contiguous_nested_list_view_returns_error() -> VortexResult<()>
+    {
         let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
 
-        let out_of_line = b"this binary payload is longer than twelve bytes";
-        let array = VarBinViewArray::from_iter_nullable_bin([
-            Some(b"" as &[u8]),
-            Some(b"\x00\xff\xfe"),
-            None,
-            Some(b"short"),
-            Some(out_of_line),
-        ])
+        let field = primitive_i32_on_device(0..4, &mut ctx).await?;
+        let elements = StructArray::new(
+            FieldNames::from_iter(["x"]),
+            vec![field],
+            4,
+            Validity::NonNullable,
+        )
         .into_array();
-        let mut exported = array.export_device_array_with_schema(&mut ctx).await?;
+        let offsets = primitive_i32_on_device([0, 1], &mut ctx).await?;
+        let sizes = primitive_i32_on_device([3, 2], &mut ctx).await?;
+        let array =
+            ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
+        let err = match array.export_device_array(&mut ctx).await {
+            Ok(mut exported) => {
+                unsafe { release_exported_array(&raw mut exported.array) };
+                vortex_bail!("non-contiguous nested list view should be unsupported")
+            }
+            Err(err) => err,
+        };
 
-        let field = Field::try_from(&exported.schema)?;
-        assert_eq!(field, Field::new("", DataType::BinaryView, true));
-        assert_varbinview_layout(&exported.array.array, 5, 1, &[out_of_line.len()])?;
-        assert_eq!(exported.array.device_type, ARROW_DEVICE_CUDA);
+        assert!(
+            err.to_string()
+                .contains("GPU child rebuild only supports primitive children"),
+            "unexpected error: {err}"
+        );
+        Ok(())
+    }
 
-        unsafe { release_exported_array(&raw mut exported.array.array) };
+    #[crate::test]
+    async fn test_export_device_non_contiguous_nullable_primitive_list_view_returns_error()
+    -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let elements = nullable_primitive_i32_on_device(
+            [Some(10), None, Some(12), Some(13), Some(14)],
+            &mut ctx,
+        )
+        .await?;
+        let offsets = primitive_i32_on_device([3, 0, 2], &mut ctx).await?;
+        let sizes = primitive_i32_on_device([2, 2, 1], &mut ctx).await?;
+        let array =
+            ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
+        let err = match array.export_device_array(&mut ctx).await {
+            Ok(mut exported) => {
+                unsafe { release_exported_array(&raw mut exported.array) };
+                vortex_bail!("non-contiguous nullable primitive list view should be unsupported")
+            }
+            Err(err) => err,
+        };
+
+        assert!(
+            err.to_string()
+                .contains("GPU child validity rebuild is not implemented"),
+            "unexpected error: {err}"
+        );
         Ok(())
     }
 
-    #[rstest]
-    #[case::utf8(
-        multi_buffer_varbinview(DType::Utf8(Nullability::NonNullable)),
-        DataType::Utf8View
-    )]
-    #[case::binary(
-        multi_buffer_varbinview(DType::Binary(Nullability::NonNullable)),
-        DataType::BinaryView
-    )]
     #[crate::test]
-    async fn test_export_varbinview_multiple_variadic_buffers(
-        #[case] fixture: (ArrayRef, [usize; 2]),
-        #[case] expected_data_type: DataType,
-    ) -> VortexResult<()> {
+    async fn test_export_fixed_size_list_as_list() -> VortexResult<()> {
         let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
 
-        let (array, expected_data_buffer_lengths) = fixture;
+        let array = FixedSizeListArray::new(
+            PrimitiveArray::from_iter(0i32..6).into_array(),
+            2,
+            Validity::NonNullable,
+            3,
+        )
+        .into_array();
         let mut exported = array.export_device_array_with_schema(&mut ctx).await?;
 
         let field = Field::try_from(&exported.schema)?;
-        assert_eq!(field, Field::new("", expected_data_type, false));
-        assert_varbinview_layout(&exported.array.array, 3, 0, &expected_data_buffer_lengths)?;
+        assert_eq!(
+            field,
+            Field::new_list(
+                "",
+                Field::new(Field::LIST_FIELD_DEFAULT_NAME, DataType::Int32, false),
+                false,
+            )
+        );
+        assert_eq!(exported.array.array.length, 3);
+        assert_eq!(exported.array.array.null_count, 0);
+        assert_eq!(exported.array.array.n_buffers, 2);
+        let buffers = unsafe { std::slice::from_raw_parts(exported.array.array.buffers, 2) };
+        assert!(buffers[0].is_null());
+        assert!(!buffers[1].is_null());
+        assert_eq!(
+            private_data_buffer_i32_values(&exported.array.array, 1)?,
+            [0, 2, 4, 6]
+        );
+        assert_eq!(exported.array.array.n_children, 1);
+        let children = unsafe { std::slice::from_raw_parts(exported.array.array.children, 1) };
+        let elements = unsafe { &*children[0] };
+        assert_eq!(elements.length, 6);
+        assert_eq!(elements.n_buffers, 2);
         assert_eq!(exported.array.device_type, ARROW_DEVICE_CUDA);
 
         unsafe { release_exported_array(&raw mut exported.array.array) };
@@ -795,19 +2760,28 @@ mod tests {
         let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
             .vortex_expect("failed to create execution context");
 
-        let utf8 = VarBinViewArray::from_iter_str([
-            "skip this out-of-line value before the slice",
-            "hello",
-            "こんにちは",
-            "this out-of-line value remains in the slice",
+        let utf8 = VarBinViewArray::from_iter_nullable_str([
+            Some("skip this out-of-line value before the slice"),
+            Some("hello"),
+            None,
+            Some("this out-of-line value remains in the slice"),
         ])
         .into_array()
         .slice(1..4)?;
         let mut exported = utf8.export_device_array_with_schema(&mut ctx).await?;
         let field = Field::try_from(&exported.schema)?;
-        assert_eq!(field, Field::new("", DataType::Utf8View, false));
-        assert_varbinview_shape(&exported.array.array, 3, 0)?;
+        assert_eq!(field, Field::new("", DataType::Utf8View, true));
+        assert_varbinview_shape(&exported.array.array, 3, 1)?;
         assert_eq!(exported.array.device_type, ARROW_DEVICE_CUDA);
+
+        let private_data = unsafe { &*exported.array.array.private_data.cast::<PrivateData>() };
+        let null_buffer = private_data.buffers[0]
+            .as_ref()
+            .vortex_expect("sliced null buffer should be present");
+        let null_bits = BitBuffer::new(null_buffer.to_host_sync(), 3)
+            .iter()
+            .collect::<Vec<_>>();
+        assert_eq!(null_bits, [true, false, true]);
         unsafe { release_exported_array(&raw mut exported.array.array) };
 
         let binary = VarBinViewArray::from_iter_nullable_bin([
@@ -820,14 +2794,120 @@ mod tests {
         .slice(1..4)?;
         let mut exported = binary.export_device_array_with_schema(&mut ctx).await?;
         let field = Field::try_from(&exported.schema)?;
-        assert_eq!(field, Field::new("", DataType::BinaryView, true));
-        assert_varbinview_shape(&exported.array.array, 3, 1)?;
+        assert_eq!(field, Field::new("", DataType::Binary, true));
+        let sliced_out_of_line = b"this out-of-line binary value remains in the slice";
+        assert_binary_layout(
+            &exported.array.array,
+            3,
+            1,
+            &[0, 0, 2, i32::try_from(2 + sliced_out_of_line.len())?],
+            &[b"\x00\xff".as_slice(), sliced_out_of_line].concat(),
+        )?;
         assert_eq!(exported.array.device_type, ARROW_DEVICE_CUDA);
         unsafe { release_exported_array(&raw mut exported.array.array) };
 
         Ok(())
     }
 
+    #[rstest::rstest]
+    #[case::input_ahead_of_arrow(5, 3, 9)]
+    #[case::arrow_ahead_of_input(3, 70, 9)]
+    #[case::equal_offsets(7, 7, 9)]
+    #[case::byte_aligned_input(0, 9, 9)]
+    #[case::word_aligned_offsets(64, 128, 130)]
+    #[case::multi_word(13, 0, 301)]
+    #[crate::test]
+    async fn test_repack_arrow_validity_buffer_offsets(
+        #[case] input_offset: usize,
+        #[case] arrow_offset: usize,
+        #[case] len: usize,
+    ) -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let logical_bits = (0..len).map(|idx| idx % 3 != 0).collect::<Vec<_>>();
+        // All-true filler before the slice would leak into the output if offsets were mishandled.
+        let source = BitBuffer::from_iter(
+            std::iter::repeat_n(true, input_offset).chain(logical_bits.iter().copied()),
+        );
+        let sliced = source.slice(input_offset..input_offset + len);
+        // BitBuffer rebases whole bytes into the backing buffer, keeping the bit offset below 8.
+        let (input_offset, _, input_buffer) = sliced.into_inner();
+
+        let input_buffer = ctx
+            .ensure_on_device(BufferHandle::new_host(input_buffer))
+            .await?;
+        let output_bits = len + arrow_offset;
+        let output =
+            repack_arrow_validity_buffer(&input_buffer, input_offset, len, arrow_offset, &mut ctx)?;
+        ctx.synchronize_stream()?;
+
+        let actual = BitBuffer::new(output.to_host_sync(), output_bits)
+            .iter()
+            .collect::<Vec<_>>();
+        let expected = std::iter::repeat_n(false, arrow_offset)
+            .chain(logical_bits)
+            .collect::<Vec<_>>();
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_repack_arrow_validity_buffer_zeroes_padding() -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let len = 9;
+        let arrow_offset = 3;
+        let source = BitBuffer::from_iter(std::iter::repeat_n(true, len));
+        let (input_offset, _, input_buffer) = source.into_inner();
+        let input_buffer = ctx
+            .ensure_on_device(BufferHandle::new_host(input_buffer))
+            .await?;
+        let output_bytes = (len + arrow_offset).div_ceil(8);
+
+        let output =
+            repack_arrow_validity_buffer(&input_buffer, input_offset, len, arrow_offset, &mut ctx)?;
+        ctx.synchronize_stream()?;
+
+        assert_eq!(output.len(), output_bytes);
+        let backing = cuda_backing_allocation(&output)?;
+        let backing_bytes = backing.to_host_sync();
+        assert_eq!(
+            backing_bytes.len(),
+            output_bytes.next_multiple_of(size_of::<u64>())
+        );
+        assert!(backing_bytes[output_bytes..].iter().all(|byte| *byte == 0));
+
+        Ok(())
+    }
+
+    #[crate::test]
+    async fn test_export_all_false_validity_buffer_is_zeroed_on_device() -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let len = 4;
+        let arrow_offset = 5;
+        let (buffer, null_count) = export_arrow_validity_buffer(
+            Validity::from(BitBuffer::from_iter(std::iter::repeat_n(false, len))),
+            len,
+            arrow_offset,
+            &mut ctx,
+        )
+        .await?;
+        ctx.synchronize_stream()?;
+
+        assert_eq!(null_count, i64::try_from(len)?);
+        let buffer = buffer.vortex_expect("all-false validity should export a null buffer");
+        let bytes = buffer.to_host_sync();
+        assert_eq!(bytes.len(), (len + arrow_offset).div_ceil(8));
+        assert!(bytes.iter().all(|byte| *byte == 0));
+
+        Ok(())
+    }
+
     // Check nullable primitives export Arrow null bitmaps on device.
     #[crate::test]
     async fn test_export_nullable_primitive() -> VortexResult<()> {
@@ -919,6 +2999,14 @@ mod tests {
             &mut ctx,
         )
         .await?;
+
+        let private_data = unsafe { &*decimal.array.private_data.cast::<PrivateData>() };
+        let value_buffer = private_data.buffers[1]
+            .as_ref()
+            .vortex_expect("value buffer should be present");
+        assert_eq!(value_buffer.len(), 3 * size_of::<i64>());
+        assert_exported_decimal_values(value_buffer, &[100i64, 0, 300]);
+
         unsafe { release_exported_array(&raw mut decimal.array) };
 
         Ok(())
@@ -1194,6 +3282,67 @@ mod tests {
         Ok(())
     }
 
+    #[crate::test]
+    async fn test_export_nested_struct_decimal_with_schema() -> VortexResult<()> {
+        let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
+            .vortex_expect("failed to create execution context");
+
+        let nested = StructArray::new(
+            FieldNames::from_iter(["amount"]),
+            vec![
+                DecimalArray::from_iter([100i32, -200, 300], DecimalDType::new(9, 2)).into_array(),
+            ],
+            3,
+            Validity::NonNullable,
+        )
+        .into_array();
+        let array = StructArray::new(
+            FieldNames::from_iter(["nested"]),
+            vec![nested],
+            3,
+            Validity::NonNullable,
+        )
+        .into_array();
+        let mut exported = array.export_device_array_with_schema(&mut ctx).await?;
+
+        let schema = Schema::try_from(&exported.schema)?;
+        assert_eq!(
+            schema,
+            Schema::new(vec![Field::new(
+                "nested",
+                DataType::Struct(Fields::from(vec![Field::new(
+                    "amount",
+                    DataType::Decimal32(9, 2),
+                    false,
+                )])),
+                false,
+            )])
+        );
+
+        let children = unsafe {
+            std::slice::from_raw_parts(
+                exported.array.array.children,
+                usize::try_from(exported.array.array.n_children)?,
+            )
+        };
+        let nested_child = unsafe { &*children[0] };
+        let nested_children = unsafe {
+            std::slice::from_raw_parts(
+                nested_child.children,
+                usize::try_from(nested_child.n_children)?,
+            )
+        };
+        let decimal_child = unsafe { &*nested_children[0] };
+        let private_data = unsafe { &*decimal_child.private_data.cast::<PrivateData>() };
+        let value_buffer = private_data.buffers[1]
+            .as_ref()
+            .vortex_expect("value buffer should be present");
+        assert_eq!(value_buffer.len(), 3 * size_of::<i32>());
+
+        unsafe { release_exported_array(&raw mut exported.array.array) };
+        Ok(())
+    }
+
     #[crate::test]
     async fn test_export_primitive_with_schema_is_column_shaped() -> VortexResult<()> {
         let mut ctx = CudaSession::create_execution_ctx(&VortexSession::empty())
diff --git a/vortex-cuda/src/arrow/list_view.rs b/vortex-cuda/src/arrow/list_view.rs
new file mode 100644
index 00000000000..6e3f25a939f
--- /dev/null
+++ b/vortex-cuda/src/arrow/list_view.rs
@@ -0,0 +1,550 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! CUDA Arrow Device export helpers for Vortex `ListViewArray`.
+
+use std::sync::Arc;
+
+use cudarc::driver::CudaSlice;
+use cudarc::driver::DeviceRepr;
+use cudarc::driver::PushKernelArg;
+use vortex::array::ArrayRef;
+use vortex::array::Canonical;
+use vortex::array::IntoArray;
+use vortex::array::arrays::Dict;
+use vortex::array::arrays::DictArray;
+use vortex::array::arrays::ListViewArray;
+use vortex::array::arrays::PrimitiveArray;
+use vortex::array::arrays::dict::DictOwnedExt;
+use vortex::array::arrays::listview::ListViewDataParts;
+use vortex::array::arrays::primitive::PrimitiveDataParts;
+use vortex::array::buffer::BufferHandle;
+use vortex::array::match_each_integer_ptype;
+use vortex::buffer::Buffer;
+use vortex::dtype::NativePType;
+use vortex::dtype::PType;
+use vortex::error::VortexResult;
+use vortex::error::vortex_bail;
+use vortex::error::vortex_ensure;
+use vortex::error::vortex_err;
+
+use super::ArrowArray;
+use super::SyncEvent;
+use super::canonical::ListChildExport;
+use super::canonical::export_arrow_validity_buffer;
+use super::canonical::export_list_layout;
+use crate::CudaBufferExt;
+use crate::CudaDeviceBuffer;
+use crate::CudaExecutionCtx;
+use crate::cub::exclusive_sum_i32;
+use crate::executor::CudaArrayExt;
+
+/// Export a Vortex list-view as an Arrow Device array with `List` layout using device kernels.
+///
+/// Reuses contiguous children; rebuilds non-contiguous primitive or dictionary-code children.
+pub(super) async fn export_device_list_view(
+    array: ListViewArray,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<(ArrowArray, SyncEvent)> {
+    let len = array.len();
+    let ListViewDataParts {
+        elements,
+        offsets,
+        sizes,
+        validity,
+        ..
+    } = array.into_data_parts();
+
+    let (validity_buffer, null_count) = export_arrow_validity_buffer(validity, len, 0, ctx).await?;
+
+    let (offsets_ptype, offsets_buffer) =
+        primitive_device_buffer(offsets, "list offsets", ctx).await?;
+    let (sizes_ptype, sizes_buffer) = primitive_device_buffer(sizes, "list sizes", ctx).await?;
+
+    match export_device_list_view_offsets(
+        offsets_ptype,
+        offsets_buffer.clone(),
+        sizes_ptype,
+        sizes_buffer.clone(),
+        len,
+        ctx,
+    )
+    .await?
+    {
+        DeviceListViewOffsets::Contiguous(offsets_buffer) => {
+            export_list_layout(
+                elements,
+                len,
+                validity_buffer,
+                null_count,
+                offsets_buffer,
+                ListChildExport::PreserveConcreteLayout,
+                ctx,
+            )
+            .await
+        }
+        DeviceListViewOffsets::RequiresRebuild => match elements.try_downcast::<Dict>() {
+            Ok(dict) => {
+                export_rebuilt_dict_list_view(
+                    dict,
+                    offsets_ptype,
+                    offsets_buffer,
+                    sizes_ptype,
+                    sizes_buffer,
+                    len,
+                    validity_buffer,
+                    null_count,
+                    ctx,
+                )
+                .await
+            }
+            Err(elements) => {
+                export_rebuilt_primitive_list_view(
+                    elements,
+                    offsets_ptype,
+                    offsets_buffer,
+                    sizes_ptype,
+                    sizes_buffer,
+                    len,
+                    validity_buffer,
+                    null_count,
+                    ctx,
+                )
+                .await
+            }
+        },
+    }
+}
+
+enum DeviceListViewOffsets {
+    Contiguous(BufferHandle),
+    RequiresRebuild,
+}
+
+/// Build Arrow Device `List` offsets from list-view offset/size device buffers.
+#[expect(clippy::cognitive_complexity)]
+async fn export_device_list_view_offsets(
+    offsets_ptype: PType,
+    offsets_buffer: BufferHandle,
+    sizes_ptype: PType,
+    sizes_buffer: BufferHandle,
+    len: usize,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<DeviceListViewOffsets> {
+    if len == 0 {
+        let offsets = ctx
+            .ensure_on_device(BufferHandle::new_host(
+                Buffer::from(vec![0i32]).into_byte_buffer(),
+            ))
+            .await?;
+        return Ok(DeviceListViewOffsets::Contiguous(offsets));
+    }
+
+    match_each_integer_ptype!(offsets_ptype, |O| {
+        match_each_integer_ptype!(sizes_ptype, |S| {
+            export_device_list_view_offsets_typed::<O, S>(offsets_buffer, sizes_buffer, len, ctx)
+                .await
+        })
+    })
+}
+
+/// Rebuild primitive list-view offsets and values for concrete offset and size types.
+async fn rebuild_primitive_list_view_typed<O, S>(
+    offsets: BufferHandle,
+    sizes: BufferHandle,
+    values: BufferHandle,
+    elements_len: usize,
+    list_len: usize,
+    values_ptype: PType,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<(BufferHandle, BufferHandle)>
+where
+    O: NativePType + DeviceRepr + Send + Sync + 'static,
+    S: NativePType + DeviceRepr + Send + Sync + 'static,
+{
+    let status = new_list_view_status(ctx).await?;
+    let scan_len = list_len + 1;
+
+    let scan_input = init_list_view_rebuild_scan::<S>(&sizes, &status, list_len, ctx)?;
+    let output_offsets = BufferHandle::new_device(Arc::new(CudaDeviceBuffer::new(
+        exclusive_sum_i32(&scan_input, scan_len, ctx)?,
+    )));
+
+    validate_list_view_rebuild_offsets::<S>(&sizes, &output_offsets, &status, list_len, ctx)?;
+    check_list_view_rebuild_status(&status).await?;
+
+    let total_values = total_values_from_offsets(&output_offsets, list_len).await?;
+    let value_width = values_ptype.byte_width();
+    let output_values_bytes = total_values
+        .checked_mul(value_width)
+        .ok_or_else(|| vortex_err!("rebuilt list child byte length overflow"))?;
+
+    let output_values = gather_rebuilt_primitive_values::<O, S>(
+        &offsets,
+        &sizes,
+        &values,
+        &output_offsets,
+        output_values_bytes,
+        elements_len,
+        list_len,
+        value_width,
+        &status,
+        ctx,
+    )?;
+    check_list_view_rebuild_status(&status).await?;
+
+    let values = BufferHandle::new_device(Arc::new(CudaDeviceBuffer::new(output_values)))
+        .slice(0..output_values_bytes);
+    Ok((output_offsets, values))
+}
+
+/// Allocate the device status word used by list-view rebuild kernels.
+async fn new_list_view_status(ctx: &mut CudaExecutionCtx) -> VortexResult<BufferHandle> {
+    ctx.ensure_on_device(BufferHandle::new_host(
+        Buffer::from(vec![0u32]).into_byte_buffer(),
+    ))
+    .await
+}
+
+/// Convert the list-view rebuild status word into a Vortex error.
+async fn check_list_view_rebuild_status(status: &BufferHandle) -> VortexResult<()> {
+    match Buffer::<u32>::from_byte_buffer(status.try_to_host()?.await?)[0] {
+        0 => Ok(()),
+        1 => vortex_bail!(
+            "cannot export device-resident ListViewArray as Arrow List: offsets/sizes are invalid for the child elements"
+        ),
+        2 => vortex_bail!(
+            "cannot export device-resident ListViewArray as Arrow List: offsets exceed i32 range required by cuDF"
+        ),
+        status => vortex_bail!("unexpected list-view rebuild status {status}"),
+    }
+}
+
+/// Initialize the exclusive-scan input for rebuilt Arrow List offsets.
+fn init_list_view_rebuild_scan<S>(
+    sizes: &BufferHandle,
+    status: &BufferHandle,
+    list_len: usize,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<CudaSlice<i32>>
+where
+    S: NativePType + DeviceRepr + Send + Sync + 'static,
+{
+    let scan_len = list_len + 1;
+    let sizes_view = sizes.cuda_view::<S>()?;
+    let status_view = status.cuda_view::<u32>()?;
+    let list_len_u64 = list_len as u64;
+    let scan_len_u64 = scan_len as u64;
+    let scan_input = ctx.device_alloc::<i32>(scan_len)?;
+    let init_kernel = ctx
+        .load_function_with_suffixes("list_view", &["rebuild_init_scan", &S::PTYPE.to_string()])?;
+
+    ctx.launch_kernel(&init_kernel, scan_len, |args| {
+        args.arg(&sizes_view)
+            .arg(&scan_input)
+            .arg(&status_view)
+            .arg(&list_len_u64)
+            .arg(&scan_len_u64);
+    })?;
+
+    Ok(scan_input)
+}
+
+/// Validate rebuilt Arrow List offsets and flag invalid views on device.
+fn validate_list_view_rebuild_offsets<S>(
+    sizes: &BufferHandle,
+    output_offsets: &BufferHandle,
+    status: &BufferHandle,
+    list_len: usize,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<()>
+where
+    S: NativePType + DeviceRepr + Send + Sync + 'static,
+{
+    let sizes_view = sizes.cuda_view::<S>()?;
+    let output_offsets_view = output_offsets.cuda_view::<i32>()?;
+    let status_view = status.cuda_view::<u32>()?;
+    let list_len_u64 = list_len as u64;
+    let validate_kernel = ctx.load_function_with_suffixes(
+        "list_view",
+        &["rebuild_validate_offsets", &S::PTYPE.to_string()],
+    )?;
+
+    ctx.launch_kernel(&validate_kernel, list_len, |args| {
+        args.arg(&sizes_view)
+            .arg(&output_offsets_view)
+            .arg(&status_view)
+            .arg(&list_len_u64);
+    })
+}
+
+/// Read the final rebuilt offset to determine the output child length.
+async fn total_values_from_offsets(
+    output_offsets: &BufferHandle,
+    list_len: usize,
+) -> VortexResult<usize> {
+    let total_values = Buffer::<i32>::from_byte_buffer(
+        output_offsets
+            .slice_typed::<i32>(list_len..list_len + 1)
+            .try_to_host()?
+            .await?,
+    )[0];
+
+    usize::try_from(total_values).map_err(Into::into)
+}
+
+/// Gather primitive child bytes from each list-view range into contiguous list order.
+#[expect(clippy::too_many_arguments)]
+fn gather_rebuilt_primitive_values<O, S>(
+    offsets: &BufferHandle,
+    sizes: &BufferHandle,
+    values: &BufferHandle,
+    output_offsets: &BufferHandle,
+    output_values_bytes: usize,
+    elements_len: usize,
+    list_len: usize,
+    value_width: usize,
+    status: &BufferHandle,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<CudaSlice<u8>>
+where
+    O: NativePType + DeviceRepr + Send + Sync + 'static,
+    S: NativePType + DeviceRepr + Send + Sync + 'static,
+{
+    let offsets_view = offsets.cuda_view::<O>()?;
+    let sizes_view = sizes.cuda_view::<S>()?;
+    let values_view = values.cuda_view::<u8>()?;
+    let output_offsets_view = output_offsets.cuda_view::<i32>()?;
+    let output_values = ctx.device_alloc::<u8>(output_values_bytes.max(1))?;
+    let status_view = status.cuda_view::<u32>()?;
+    let list_len_u64 = list_len as u64;
+    let elements_len_u64 = elements_len as u64;
+    let value_width_u64 = value_width as u64;
+    let rebuild_kernel = ctx.load_function_with_suffixes(
+        "list_view",
+        &[
+            "rebuild_primitive",
+            &O::PTYPE.to_string(),
+            &S::PTYPE.to_string(),
+        ],
+    )?;
+
+    ctx.launch_kernel(&rebuild_kernel, list_len, |args| {
+        args.arg(&offsets_view)
+            .arg(&sizes_view)
+            .arg(&output_offsets_view)
+            .arg(&values_view)
+            .arg(&output_values)
+            .arg(&status_view)
+            .arg(&list_len_u64)
+            .arg(&elements_len_u64)
+            .arg(&value_width_u64);
+    })?;
+
+    Ok(output_values)
+}
+
+/// Rebuild non-contiguous dictionary list-view codes while reusing the dictionary values.
+#[expect(clippy::too_many_arguments)]
+async fn export_rebuilt_dict_list_view(
+    dict: DictArray,
+    offsets_ptype: PType,
+    offsets_buffer: BufferHandle,
+    sizes_ptype: PType,
+    sizes_buffer: BufferHandle,
+    len: usize,
+    validity_buffer: Option<BufferHandle>,
+    null_count: i64,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<(ArrowArray, SyncEvent)> {
+    let parts = dict.into_parts();
+    let canonical_codes = parts.codes.execute_cuda(ctx).await?;
+    let Canonical::Primitive(codes) = canonical_codes else {
+        vortex_bail!(
+            "cannot export non-contiguous device-resident ListViewArray with dictionary codes of {}: GPU child rebuild only supports primitive dictionary codes",
+            canonical_codes.dtype()
+        );
+    };
+
+    let (offsets_buffer, rebuilt_codes) = rebuild_primitive_list_view_child(
+        codes,
+        "dictionary codes",
+        offsets_ptype,
+        offsets_buffer,
+        sizes_ptype,
+        sizes_buffer,
+        len,
+        ctx,
+    )
+    .await?;
+    let rebuilt_dict = DictArray::try_new(rebuilt_codes.into_array(), parts.values)?.into_array();
+
+    export_list_layout(
+        rebuilt_dict,
+        len,
+        validity_buffer,
+        null_count,
+        offsets_buffer,
+        ListChildExport::PreserveConcreteLayout,
+        ctx,
+    )
+    .await
+}
+
+/// Rebuild a non-contiguous primitive list-view child and export it as Arrow Device `List`.
+#[expect(clippy::too_many_arguments)]
+async fn export_rebuilt_primitive_list_view(
+    elements: ArrayRef,
+    offsets_ptype: PType,
+    offsets_buffer: BufferHandle,
+    sizes_ptype: PType,
+    sizes_buffer: BufferHandle,
+    len: usize,
+    validity_buffer: Option<BufferHandle>,
+    null_count: i64,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<(ArrowArray, SyncEvent)> {
+    let canonical_elements = elements.execute_cuda(ctx).await?;
+    let Canonical::Primitive(elements) = canonical_elements else {
+        vortex_bail!(
+            "cannot export non-contiguous device-resident ListViewArray with {} child: GPU child rebuild only supports primitive children",
+            canonical_elements.dtype()
+        );
+    };
+
+    let (offsets_buffer, rebuilt_elements) = rebuild_primitive_list_view_child(
+        elements,
+        "primitive child",
+        offsets_ptype,
+        offsets_buffer,
+        sizes_ptype,
+        sizes_buffer,
+        len,
+        ctx,
+    )
+    .await?;
+
+    export_list_layout(
+        rebuilt_elements.into_array(),
+        len,
+        validity_buffer,
+        null_count,
+        offsets_buffer,
+        ListChildExport::PreserveConcreteLayout,
+        ctx,
+    )
+    .await
+}
+
+/// Gather a non-contiguous primitive child into list order and return new offsets and values.
+#[expect(clippy::cognitive_complexity, clippy::too_many_arguments)]
+async fn rebuild_primitive_list_view_child(
+    elements: PrimitiveArray,
+    child_name: &str,
+    offsets_ptype: PType,
+    offsets_buffer: BufferHandle,
+    sizes_ptype: PType,
+    sizes_buffer: BufferHandle,
+    len: usize,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<(BufferHandle, PrimitiveArray)> {
+    let elements_len = elements.len();
+    let PrimitiveDataParts {
+        ptype,
+        buffer,
+        validity,
+        ..
+    } = elements.into_data_parts();
+
+    vortex_ensure!(
+        validity.execute_no_nulls(elements_len, ctx.execution_ctx())?,
+        "cannot export non-contiguous device-resident ListViewArray with nullable {child_name}: GPU child validity rebuild is not implemented"
+    );
+
+    let values_buffer = ctx.ensure_on_device(buffer).await?;
+    let (offsets_buffer, values_buffer) = match_each_integer_ptype!(offsets_ptype, |O| {
+        match_each_integer_ptype!(sizes_ptype, |S| {
+            rebuild_primitive_list_view_typed::<O, S>(
+                offsets_buffer,
+                sizes_buffer,
+                values_buffer,
+                elements_len,
+                len,
+                ptype,
+                ctx,
+            )
+            .await
+        })
+    })?;
+
+    Ok((
+        offsets_buffer,
+        PrimitiveArray::from_buffer_handle(values_buffer, ptype, validity),
+    ))
+}
+
+/// Execute an integer array on CUDA and return its primitive type and device buffer.
+async fn primitive_device_buffer(
+    array: ArrayRef,
+    name: &str,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<(PType, BufferHandle)> {
+    let canonical = array.execute_cuda(ctx).await?;
+    let Canonical::Primitive(primitive) = canonical else {
+        vortex_bail!("{name} must be primitive, got {}", canonical.dtype());
+    };
+
+    let PrimitiveDataParts { ptype, buffer, .. } = primitive.into_data_parts();
+    vortex_ensure!(ptype.is_int(), "{name} must have integer type, got {ptype}");
+
+    Ok((ptype, ctx.ensure_on_device(buffer).await?))
+}
+
+/// Compute Arrow List offsets and report whether child values must be rebuilt.
+async fn export_device_list_view_offsets_typed<O, S>(
+    offsets: BufferHandle,
+    sizes: BufferHandle,
+    len: usize,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<DeviceListViewOffsets>
+where
+    O: NativePType + DeviceRepr + Send + Sync + 'static,
+    S: NativePType + DeviceRepr + Send + Sync + 'static,
+{
+    let output_len = len + 1;
+    let output = ctx.device_alloc::<i32>(output_len)?;
+
+    let status = ctx
+        .ensure_on_device(BufferHandle::new_host(
+            Buffer::from(vec![0u32]).into_byte_buffer(),
+        ))
+        .await?;
+
+    let offsets_view = offsets.cuda_view::<O>()?;
+    let sizes_view = sizes.cuda_view::<S>()?;
+    let status_view = status.cuda_view::<u32>()?;
+    let list_len_u64 = len as u64;
+
+    let kernel = ctx.load_function_with_suffixes(
+        "list_view",
+        &["offsets", &O::PTYPE.to_string(), &S::PTYPE.to_string()],
+    )?;
+    ctx.launch_kernel(&kernel, len, |args| {
+        args.arg(&offsets_view)
+            .arg(&sizes_view)
+            .arg(&output)
+            .arg(&status_view)
+            .arg(&list_len_u64);
+    })?;
+
+    match Buffer::<u32>::from_byte_buffer(status.try_to_host()?.await?)[0] {
+        0 => Ok(DeviceListViewOffsets::Contiguous(BufferHandle::new_device(
+            Arc::new(CudaDeviceBuffer::new(output)),
+        ))),
+        1 => Ok(DeviceListViewOffsets::RequiresRebuild),
+        2 => vortex_bail!(
+            "cannot export device-resident ListViewArray as Arrow List: offsets exceed i32 range required by cuDF"
+        ),
+        status => vortex_bail!("unexpected list-view offsets kernel status {status}"),
+    }
+}
diff --git a/vortex-cuda/src/arrow/mod.rs b/vortex-cuda/src/arrow/mod.rs
index 3739a12e6ec..7dac0c8631d 100644
--- a/vortex-cuda/src/arrow/mod.rs
+++ b/vortex-cuda/src/arrow/mod.rs
@@ -9,12 +9,16 @@
 //! More documentation at <https://arrow.apache.org/docs/format/CDeviceDataInterface.html>
 
 mod canonical;
+mod list_view;
 
 use std::ffi::c_void;
 use std::fmt::Debug;
 use std::ptr;
 use std::sync::Arc;
 
+use arrow_schema::DataType;
+use arrow_schema::Field;
+use arrow_schema::Schema;
 use arrow_schema::ffi::FFI_ArrowSchema;
 use async_trait::async_trait;
 pub(crate) use canonical::CanonicalDeviceArrayExport;
@@ -22,9 +26,23 @@ use cudarc::driver::CudaEvent;
 use cudarc::driver::CudaStream;
 use cudarc::runtime::sys::cudaEvent_t;
 use vortex::array::ArrayRef;
+use vortex::array::arrays::Dict;
+use vortex::array::arrays::FixedSizeList;
+use vortex::array::arrays::List;
+use vortex::array::arrays::ListView;
+use vortex::array::arrays::Struct;
+use vortex::array::arrays::dict::DictArraySlotsExt;
+use vortex::array::arrays::fixed_size_list::FixedSizeListArrayExt;
+use vortex::array::arrays::list::ListArrayExt;
+use vortex::array::arrays::listview::ListViewArrayExt;
+use vortex::array::arrays::struct_::StructArrayExt;
 use vortex::array::arrow::ArrowSessionExt;
 use vortex::array::buffer::BufferHandle;
 use vortex::dtype::DType;
+use vortex::dtype::DecimalDType;
+use vortex::dtype::DecimalType;
+use vortex::dtype::PType;
+use vortex::dtype::StructFields;
 use vortex::error::VortexResult;
 use vortex::error::vortex_err;
 
@@ -45,6 +63,27 @@ pub use arrow_c_abi::ArrowArray;
 pub use arrow_c_abi::ArrowDeviceArray;
 pub use arrow_c_abi::ArrowDeviceType;
 
+#[cfg(feature = "_test-harness")]
+#[doc(hidden)]
+pub mod test_harness {
+    use vortex::array::buffer::BufferHandle;
+    use vortex::error::VortexResult;
+
+    use crate::CudaExecutionCtx;
+    use crate::arrow::canonical::repack_arrow_validity_buffer as repack_arrow_validity_buffer_impl;
+
+    /// Repack a validity bitmap into Arrow's byte-addressed bitmap layout on the active stream.
+    pub fn repack_arrow_validity_buffer(
+        input_buffer: &BufferHandle,
+        input_offset: usize,
+        len: usize,
+        arrow_offset: usize,
+        ctx: &mut CudaExecutionCtx,
+    ) -> VortexResult<BufferHandle> {
+        repack_arrow_validity_buffer_impl(input_buffer, input_offset, len, arrow_offset, ctx)
+    }
+}
+
 /// CUDA device memory.
 pub const ARROW_DEVICE_CUDA: ArrowDeviceType = arrow_c_abi::ARROW_DEVICE_CUDA as ArrowDeviceType;
 
@@ -87,13 +126,25 @@ pub(crate) struct PrivateData {
     pub(crate) cuda_event: CudaEvent,
     pub(crate) cuda_event_ptr: cudaEvent_t,
     pub(crate) children: Box<[*mut ArrowArray]>,
+    pub(crate) dictionary: *mut ArrowArray,
 }
 
 impl PrivateData {
+    /// Create private data for arrays that own buffers and child arrays but no dictionary.
     pub(crate) fn new(
         buffers: Vec<Option<BufferHandle>>,
         children: Vec<ArrowArray>,
         ctx: &mut CudaExecutionCtx,
+    ) -> VortexResult<Box<Self>> {
+        Self::new_with_dictionary(buffers, children, None, ctx)
+    }
+
+    /// Create private data and optionally own an Arrow dictionary child.
+    pub(crate) fn new_with_dictionary(
+        buffers: Vec<Option<BufferHandle>>,
+        children: Vec<ArrowArray>,
+        dictionary: Option<ArrowArray>,
+        ctx: &mut CudaExecutionCtx,
     ) -> VortexResult<Box<Self>> {
         let buffers = buffers.into_boxed_slice();
         let buffer_ptrs: Box<[*const c_void]> = buffers
@@ -123,16 +174,22 @@ impl PrivateData {
             .record_event(None)
             .map_err(|_| vortex_err!("failed to create cudaEvent_t"))?;
 
+        let dictionary = dictionary
+            .map(|array| Box::into_raw(Box::new(array)))
+            .unwrap_or(ptr::null_mut());
+
         Ok(Box::new(Self {
             buffers,
             buffer_ptrs,
             cuda_stream: Arc::clone(ctx.stream()),
             children,
+            dictionary,
             cuda_event_ptr: cuda_event.cu_event().cast(),
             cuda_event,
         }))
     }
 
+    /// Return a stable pointer to the recorded CUDA event handle.
     pub(crate) fn sync_event(&mut self) -> SyncEvent {
         (&raw mut self.cuda_event_ptr).cast()
     }
@@ -157,6 +214,10 @@ pub trait DeviceArrayExt {
     ///
     /// The returned array owns any device buffers allocated during export. Call the embedded
     /// Arrow release callback when the consumer is done with the array.
+    ///
+    /// Arrow arrays are not self-describing, so callers that use this method directly must provide
+    /// a matching schema out-of-band. Prefer [`Self::export_device_array_with_schema`] unless a
+    /// consumer already has the CUDA export schema.
     async fn export_device_array(
         self,
         ctx: &mut CudaExecutionCtx,
@@ -165,13 +226,15 @@ pub trait DeviceArrayExt {
     /// Export this array as an Arrow C Device array together with its matching Arrow C schema.
     ///
     /// Arrow arrays are not self-describing: consumers need both the [`ArrowDeviceArray`] and an
-    /// Arrow schema to interpret the buffer layout. This helper derives the schema from the
-    /// Vortex dtype using the session's Arrow conversion rules and returns it alongside the device
-    /// array.
+    /// Arrow schema to interpret the buffer layout. This helper derives the schema that matches the
+    /// CUDA device export layout and returns it alongside the device array.
     ///
     /// Top-level struct arrays are exported as table-like Arrow schemas and struct-shaped device
     /// arrays. Top-level non-struct arrays are exported as column-shaped field schemas and
     /// column-shaped device arrays; this method does not wrap them in a single-field struct.
+    ///
+    /// Decimal exports use the Arrow decimal width implied by precision; storage wider than that
+    /// width is rejected rather than narrowed on device.
     async fn export_device_array_with_schema(
         self,
         ctx: &mut CudaExecutionCtx,
@@ -192,29 +255,211 @@ impl DeviceArrayExt for ArrayRef {
         self,
         ctx: &mut CudaExecutionCtx,
     ) -> VortexResult<ArrowDeviceArrayWithSchema> {
-        let schema = arrow_schema_for_array(&self, ctx)?;
-        let array = self.export_device_array(ctx).await?;
-        Ok(ArrowDeviceArrayWithSchema { schema, array })
+        let exporter = Arc::clone(ctx.exporter());
+        exporter.export_device_array_with_schema(self, ctx).await
     }
 }
 
-/// Build the Arrow C schema that describes the device array exported for `array`.
-///
-/// Top-level Vortex structs are represented as Arrow schemas, which is the shape expected for
-/// table-like consumers. Non-struct arrays are represented as a single Arrow field schema, matching
-/// the column-shaped [`ArrowDeviceArray`] returned by [`DeviceArrayExt::export_device_array`].
-fn arrow_schema_for_array(
+/// Build the Arrow C schema that describes the exported device array.
+pub(crate) fn arrow_schema_for_array(
     array: &ArrayRef,
     ctx: &mut CudaExecutionCtx,
 ) -> VortexResult<FFI_ArrowSchema> {
-    let arrow = ctx.execution_ctx().session().arrow();
-    match array.dtype() {
-        DType::Struct(..) => Ok(FFI_ArrowSchema::try_from(
-            arrow.to_arrow_schema(array.dtype())?,
-        )?),
-        _ => Ok(FFI_ArrowSchema::try_from(
-            arrow.to_arrow_field("", array.dtype())?,
-        )?),
+    if let Some(struct_array) = array.as_opt::<Struct>() {
+        return Ok(FFI_ArrowSchema::try_from(Schema::new(
+            arrow_device_export_struct_fields_for_array(
+                struct_array.names().iter(),
+                struct_array.iter_unmasked_fields(),
+                ctx,
+            )?,
+        ))?);
+    }
+
+    Ok(FFI_ArrowSchema::try_from(
+        arrow_device_export_field_for_array("", array, ctx)?,
+    )?)
+}
+
+/// Build struct fields from a logical dtype when no concrete child arrays are available.
+fn arrow_device_export_struct_fields(
+    struct_dtype: &StructFields,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<Vec<Field>> {
+    let mut fields = Vec::with_capacity(struct_dtype.nfields());
+    for (field_name, field_dtype) in struct_dtype.names().iter().zip(struct_dtype.fields()) {
+        fields.push(arrow_device_export_field(
+            field_name.as_ref(),
+            &field_dtype,
+            ctx,
+        )?);
+    }
+    Ok(fields)
+}
+
+/// Build struct fields from concrete arrays so nested encodings like dictionaries are preserved.
+fn arrow_device_export_struct_fields_for_array<'a>(
+    names: impl IntoIterator<Item = &'a vortex::dtype::FieldName>,
+    fields: impl IntoIterator<Item = &'a ArrayRef>,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<Vec<Field>> {
+    names
+        .into_iter()
+        .zip(fields)
+        .map(|(name, array)| arrow_device_export_field_for_array(name.as_ref(), array, ctx))
+        .collect()
+}
+
+/// Build the Arrow field matching how this concrete array will be exported.
+fn arrow_device_export_field_for_array(
+    name: impl AsRef<str>,
+    array: &ArrayRef,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<Field> {
+    let name = name.as_ref();
+
+    if let Some(dict) = array.as_opt::<Dict>() {
+        let codes_dtype = arrow_device_export_dictionary_codes_dtype(dict.codes().dtype())?;
+        let codes_type = arrow_device_export_field("", &codes_dtype, ctx)?
+            .data_type()
+            .clone();
+        let values_type = arrow_device_export_field_for_array("", dict.values(), ctx)?
+            .data_type()
+            .clone();
+        return Ok(Field::new(
+            name,
+            DataType::Dictionary(Box::new(codes_type), Box::new(values_type)),
+            array.dtype().is_nullable(),
+        ));
+    }
+
+    if let Some(struct_array) = array.as_opt::<Struct>() {
+        return Ok(Field::new(
+            name,
+            DataType::Struct(
+                arrow_device_export_struct_fields_for_array(
+                    struct_array.names().iter(),
+                    struct_array.iter_unmasked_fields(),
+                    ctx,
+                )?
+                .into(),
+            ),
+            array.dtype().is_nullable(),
+        ));
+    }
+
+    if let Some(list) = array.as_opt::<List>() {
+        let element = arrow_device_export_field_for_array(
+            Field::LIST_FIELD_DEFAULT_NAME,
+            list.elements(),
+            ctx,
+        )?;
+        return Ok(Field::new_list(name, element, array.dtype().is_nullable()));
+    }
+
+    if let Some(list) = array.as_opt::<ListView>() {
+        let element = arrow_device_export_field_for_array(
+            Field::LIST_FIELD_DEFAULT_NAME,
+            list.elements(),
+            ctx,
+        )?;
+        return Ok(Field::new_list(name, element, array.dtype().is_nullable()));
+    }
+
+    if let Some(list) = array.as_opt::<FixedSizeList>() {
+        let element = arrow_device_export_field_for_array(
+            Field::LIST_FIELD_DEFAULT_NAME,
+            list.elements(),
+            ctx,
+        )?;
+        return Ok(Field::new_list(name, element, array.dtype().is_nullable()));
+    }
+
+    arrow_device_export_field(name, &arrow_device_export_dtype(array.dtype()), ctx)
+}
+
+/// Return the signed dictionary code dtype used by Arrow Device export.
+fn arrow_device_export_dictionary_codes_dtype(codes_dtype: &DType) -> VortexResult<DType> {
+    // cuDF's Arrow Device importer only accepts signed dictionary indices.
+    let ptype = match codes_dtype.as_ptype() {
+        PType::U8 => PType::I16,
+        PType::U16 => PType::I32,
+        PType::U32 | PType::U64 => PType::I64,
+        ptype @ (PType::I8 | PType::I16 | PType::I32 | PType::I64) => ptype,
+        ptype => return Err(vortex_err!("dictionary codes must be integer, got {ptype}")),
+    };
+
+    Ok(DType::Primitive(ptype, codes_dtype.nullability()))
+}
+
+/// Build the Arrow field for a dtype-only export schema fallback.
+fn arrow_device_export_field(
+    name: impl AsRef<str>,
+    dtype: &DType,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<Field> {
+    let field = ctx
+        .execution_ctx()
+        .session()
+        .arrow()
+        .to_arrow_field(name.as_ref(), dtype)?;
+
+    let data_type = match dtype {
+        DType::Binary(_) => DataType::Binary,
+        DType::Decimal(decimal_dtype, _) => arrow_device_export_decimal_data_type(*decimal_dtype),
+        DType::Struct(struct_dtype, _) => {
+            DataType::Struct(arrow_device_export_struct_fields(struct_dtype, ctx)?.into())
+        }
+        _ => return Ok(field),
+    };
+
+    Ok(
+        Field::new(field.name().clone(), data_type, field.is_nullable())
+            .with_metadata(field.metadata().clone()),
+    )
+}
+
+/// Return the Arrow decimal type with the device-export physical width.
+fn arrow_device_export_decimal_data_type(decimal_dtype: DecimalDType) -> DataType {
+    match cuda_decimal_value_type(decimal_dtype) {
+        DecimalType::I32 => DataType::Decimal32(decimal_dtype.precision(), decimal_dtype.scale()),
+        DecimalType::I64 => DataType::Decimal64(decimal_dtype.precision(), decimal_dtype.scale()),
+        DecimalType::I128 => DataType::Decimal128(decimal_dtype.precision(), decimal_dtype.scale()),
+        DecimalType::I256 => DataType::Decimal256(decimal_dtype.precision(), decimal_dtype.scale()),
+        decimal_type => unreachable!("unsupported decimal value type {decimal_type}"),
+    }
+}
+
+/// Return the decimal storage width Arrow expects for a precision.
+pub(crate) fn cuda_decimal_value_type(decimal_dtype: DecimalDType) -> DecimalType {
+    match decimal_dtype.precision() {
+        1..=9 => DecimalType::I32,
+        10..=18 => DecimalType::I64,
+        19..=38 => DecimalType::I128,
+        39..=76 => DecimalType::I256,
+        p => unreachable!("precision {p} is invalid for a DecimalDType"),
+    }
+}
+
+/// Adapt Vortex logical dtypes to the Arrow Device layout this exporter emits.
+fn arrow_device_export_dtype(dtype: &DType) -> DType {
+    match dtype {
+        DType::List(element, nullability) => {
+            DType::List(Arc::new(arrow_device_export_dtype(element)), *nullability)
+        }
+        DType::FixedSizeList(element, _, nullability) => {
+            DType::List(Arc::new(arrow_device_export_dtype(element)), *nullability)
+        }
+        DType::Struct(fields, nullability) => DType::Struct(
+            StructFields::new(
+                fields.names().clone(),
+                fields
+                    .fields()
+                    .map(|dtype| arrow_device_export_dtype(&dtype))
+                    .collect(),
+            ),
+            *nullability,
+        ),
+        dtype => dtype.clone(),
     }
 }
 
@@ -233,4 +478,15 @@ pub trait ExportDeviceArray: Debug + Send + Sync + 'static {
         array: ArrayRef,
         ctx: &mut CudaExecutionCtx,
     ) -> VortexResult<ArrowDeviceArray>;
+
+    /// Export a Vortex array as an [`ArrowDeviceArray`] with a matching Arrow C schema.
+    async fn export_device_array_with_schema(
+        &self,
+        array: ArrayRef,
+        ctx: &mut CudaExecutionCtx,
+    ) -> VortexResult<ArrowDeviceArrayWithSchema> {
+        let schema = arrow_schema_for_array(&array, ctx)?;
+        let array = self.export_device_array(array, ctx).await?;
+        Ok(ArrowDeviceArrayWithSchema { schema, array })
+    }
 }
diff --git a/vortex-cuda/src/canonical.rs b/vortex-cuda/src/canonical.rs
index 591f1be404f..4f3d6fd37e3 100644
--- a/vortex-cuda/src/canonical.rs
+++ b/vortex-cuda/src/canonical.rs
@@ -75,11 +75,13 @@ impl CanonicalCudaExt for Canonical {
                 // Also update other method to copy validity to host.
                 let len = bool.len();
                 let validity = bool.validity()?;
-                let BoolDataParts {
-                    bits, offset, len, ..
-                } = bool.into_data().into_parts(len);
+                let BoolDataParts { bits, meta } = bool.into_data().into_parts(len);
 
-                let bits = BitBuffer::new_with_offset(bits.try_into_host()?.await?, offset, len);
+                let bits = BitBuffer::new_with_offset(
+                    bits.try_into_host()?.await?,
+                    meta.len(),
+                    meta.offset(),
+                );
                 Ok(Canonical::Bool(BoolArray::new(bits, validity)))
             }
             Canonical::Primitive(prim) => {
diff --git a/vortex-cuda/src/cub.rs b/vortex-cuda/src/cub.rs
new file mode 100644
index 00000000000..4b6009e7cea
--- /dev/null
+++ b/vortex-cuda/src/cub.rs
@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! CUDA wrappers around CUB scan primitives.
+
+use std::ffi::c_void;
+
+use cudarc::driver::CudaSlice;
+use cudarc::driver::DevicePtr;
+use cudarc::driver::DevicePtrMut;
+use vortex::error::VortexResult;
+use vortex::error::vortex_err;
+use vortex_cub::scan;
+use vortex_cub::scan::cudaStream_t;
+
+use crate::CudaExecutionCtx;
+
+pub(crate) fn exclusive_sum_i32(
+    input: &CudaSlice<i32>,
+    len: usize,
+    ctx: &mut CudaExecutionCtx,
+) -> VortexResult<CudaSlice<i32>> {
+    let len_i64 = i64::try_from(len)?;
+    let temp_bytes = scan::exclusive_sum_i32_temp_size(len_i64)
+        .map_err(|err| vortex_err!("CUB scan_exclusive_sum_i32_temp_size failed: {err}"))?;
+
+    let mut temp = ctx.device_alloc::<u8>(temp_bytes.max(1))?;
+    let mut output = ctx.device_alloc::<i32>(len)?;
+    let stream = ctx.stream();
+    let stream_ptr = stream.cu_stream() as cudaStream_t;
+    let (input_ptr, record_input) = input.device_ptr(stream);
+    let (output_ptr, record_output) = output.device_ptr_mut(stream);
+    let (temp_ptr, record_temp) = temp.device_ptr_mut(stream);
+
+    ctx.launch_external(len, || unsafe {
+        scan::exclusive_sum_i32(
+            temp_ptr as *mut c_void,
+            temp_bytes,
+            input_ptr as *const i32,
+            output_ptr as *mut i32,
+            len_i64,
+            stream_ptr,
+        )
+        .map_err(|err| vortex_err!("CUB scan_exclusive_sum_i32 failed: {err}"))
+    })?;
+    drop((record_input, record_output, record_temp));
+
+    Ok(output)
+}
diff --git a/vortex-cuda/src/device_buffer.rs b/vortex-cuda/src/device_buffer.rs
index e0f6477a9e3..bc07cd5daaa 100644
--- a/vortex-cuda/src/device_buffer.rs
+++ b/vortex-cuda/src/device_buffer.rs
@@ -131,6 +131,27 @@ impl CudaDeviceBuffer {
     }
 }
 
+#[cfg(test)]
+pub(crate) fn cuda_backing_allocation(handle: &BufferHandle) -> VortexResult<BufferHandle> {
+    let device_buffer = handle
+        .as_device_opt()
+        .ok_or_else(|| vortex_err!("Buffer is not on device"))?;
+
+    let cuda_buf = device_buffer
+        .as_any()
+        .downcast_ref::<CudaDeviceBuffer>()
+        .ok_or_else(|| vortex_err!("expected CudaDeviceBuffer, was {device_buffer:?}"))?;
+    let len = cuda_buf.allocation.as_bytes_view().len();
+
+    Ok(BufferHandle::new_device(Arc::new(CudaDeviceBuffer {
+        allocation: Arc::clone(&cuda_buf.allocation),
+        offset: 0,
+        len,
+        device_ptr: cuda_buf.device_ptr,
+        alignment: cuda_buf.alignment,
+    })))
+}
+
 // TODO(aduffy): we should add cuda_view_mut and enforce the borrow rules. This is a bit tricky
 //  because many executions are async, we should lean into that with ownership and having any
 //  async context actions take ownership of the buffer and return ownership when they're done.
diff --git a/vortex-cuda/src/dynamic_dispatch/mod.rs b/vortex-cuda/src/dynamic_dispatch/mod.rs
index 32e84795732..186f2297db1 100644
--- a/vortex-cuda/src/dynamic_dispatch/mod.rs
+++ b/vortex-cuda/src/dynamic_dispatch/mod.rs
@@ -405,6 +405,15 @@ impl ScalarOp {
         }
     }
 
+    /// Cast to the requested output type.
+    pub fn cast(output_ptype: PTypeTag) -> Self {
+        Self {
+            op_code: ScalarOp_ScalarOpCode_CAST,
+            output_ptype,
+            params: unsafe { std::mem::zeroed() },
+        }
+    }
+
     /// Dictionary gather: use current value as index into decoded values
     /// in shared memory (populated by an earlier input stage).
     pub fn dict(values_smem_byte_offset: u32, output_ptype: PTypeTag) -> Self {
@@ -532,11 +541,14 @@ mod tests {
     use vortex::array::IntoArray;
     use vortex::array::arrays::DictArray;
     use vortex::array::arrays::PrimitiveArray;
+    use vortex::array::builtins::ArrayBuiltins;
     use vortex::array::scalar::Scalar;
     use vortex::array::validity::Validity;
     use vortex::array::validity::Validity::NonNullable;
     use vortex::buffer::Buffer;
+    use vortex::dtype::DType;
     use vortex::dtype::NativePType;
+    use vortex::dtype::PType;
     use vortex::encodings::alp::ALP;
     use vortex::encodings::alp::ALPArrayExt;
     use vortex::encodings::alp::ALPArraySlotsExt;
@@ -591,6 +603,27 @@ mod tests {
         }
     }
 
+    #[crate::test]
+    fn test_cast_u64_to_i64_is_not_fused() -> VortexResult<()> {
+        let supported = PrimitiveArray::from_iter([0u32, 1])
+            .into_array()
+            .cast(DType::Primitive(PType::I64, Nullability::NonNullable))?;
+        assert!(matches!(
+            DispatchPlan::new(&supported, CudaDispatchMode::DynDispatchOnly)?,
+            DispatchPlan::Fused(_)
+        ));
+
+        let u64_to_i64 = PrimitiveArray::from_iter([0u64, i64::MAX as u64 + 1])
+            .into_array()
+            .cast(DType::Primitive(PType::I64, Nullability::NonNullable))?;
+        assert!(matches!(
+            DispatchPlan::new(&u64_to_i64, CudaDispatchMode::DynDispatchOnly)?,
+            DispatchPlan::Unfused
+        ));
+
+        Ok(())
+    }
+
     #[crate::test]
     fn test_max_scalar_ops() -> VortexResult<()> {
         let bit_width: u8 = 6;
diff --git a/vortex-cuda/src/dynamic_dispatch/plan_builder.rs b/vortex-cuda/src/dynamic_dispatch/plan_builder.rs
index d20af9f7d21..d7c5a58712d 100644
--- a/vortex-cuda/src/dynamic_dispatch/plan_builder.rs
+++ b/vortex-cuda/src/dynamic_dispatch/plan_builder.rs
@@ -14,8 +14,10 @@ use vortex::array::ArrayRef;
 use vortex::array::ArrayVTable;
 use vortex::array::arrays::Dict;
 use vortex::array::arrays::Primitive;
+use vortex::array::arrays::ScalarFn;
 use vortex::array::arrays::Slice;
 use vortex::array::arrays::dict::DictArraySlotsExt;
+use vortex::array::arrays::scalar_fn::ScalarFnArrayExt;
 use vortex::array::arrays::slice::SliceArrayExt;
 use vortex::array::buffer::BufferHandle;
 use vortex::array::patches::Patches;
@@ -38,6 +40,8 @@ use vortex::encodings::zigzag::ZigZagArrayExt;
 use vortex::error::VortexResult;
 use vortex::error::vortex_bail;
 use vortex::error::vortex_err;
+use vortex::scalar_fn::ScalarFnVTable;
+use vortex::scalar_fn::fns::cast::Cast;
 
 use super::CudaDispatchPlan;
 use super::MaterializedStage;
@@ -75,6 +79,9 @@ fn is_dyn_dispatch_compatible(array: &ArrayRef) -> bool {
     }
 
     let id = array.encoding_id();
+    if id == Cast.id() {
+        return is_dyn_dispatch_cast_compatible(array);
+    }
     if id == ALP.id() {
         let arr = array.as_::<ALP>();
         return matches!(arr.dtype().as_ptype(), PType::F32 | PType::F64);
@@ -126,6 +133,24 @@ fn is_dyn_dispatch_compatible(array: &ArrayRef) -> bool {
         || id == Sequence.id()
 }
 
+fn is_dyn_dispatch_cast_compatible(array: &ArrayRef) -> bool {
+    let cast = array.as_::<ScalarFn>();
+
+    let Ok(source_ptype) = PType::try_from(cast.child_at(0).dtype()) else {
+        return false;
+    };
+    let Ok(target_ptype) = PType::try_from(cast.scalar_fn().as_::<Cast>()) else {
+        return false;
+    };
+
+    // Implemented as unsigned dictionary-code casts to cuDF's signed index types.
+    // LOAD/BITUNPACK materialize directly into the target-width output type.
+    matches!(
+        (source_ptype, target_ptype),
+        (PType::U8, PType::I16) | (PType::U16, PType::I32) | (PType::U32, PType::I64)
+    )
+}
+
 /// Returns `true` if a registered standalone kernel can decode the entire
 /// `array` tree in a single launch without recursing into `execute_cuda`
 /// for child encodings.
@@ -258,7 +283,7 @@ pub struct FusedPlan {
     /// Shared memory reserved by the non-output stages, in bytes.
     smem_byte_cursor: SmemByteOffset,
     /// Source buffers. `None` entries are placeholder slots for pending subtrees,
-    /// filled by [`materialize_with_subtrees`] before device copy.
+    /// filled by [`Self::materialize_with_subtrees`] before device copy.
     source_buffers: Vec<Option<BufferHandle>>,
     /// Bytes per element of the root (output) array.
     output_elem_bytes: u32,
@@ -500,6 +525,8 @@ impl FusedPlan {
             self.walk_slice(array, pending_subtrees)
         } else if id == Sequence.id() {
             self.walk_sequence(array)
+        } else if id == Cast.id() {
+            self.walk_cast(array, pending_subtrees)
         } else {
             vortex_bail!(
                 "Encoding {:?} not supported by dynamic dispatch plan builder",
@@ -724,7 +751,7 @@ impl FusedPlan {
 
     /// Reserve a placeholder buffer slot and record the array as a pending subtree.
     ///
-    /// Called from [`walk`] when [`is_dyn_dispatch_compatible`] rejects a child.
+    /// Called from [`Self::walk`] when [`is_dyn_dispatch_compatible`] rejects a child.
     /// Cases that require a separate kernel dispatch:
     ///
     /// - **F16 primitives** — no reinterpret path in the kernel.
@@ -793,6 +820,21 @@ impl FusedPlan {
         ))
     }
 
+    fn walk_cast(
+        &mut self,
+        array: ArrayRef,
+        pending_subtrees: &mut Vec<ArrayRef>,
+    ) -> VortexResult<Stage> {
+        let cast = array.as_::<ScalarFn>();
+        let target_ptype = ptype_to_tag(cast.scalar_fn().as_::<Cast>().as_ptype());
+        let mut pipeline = self.walk(cast.child_at(0).clone(), pending_subtrees)?;
+        // LOAD/BITUNPACK directly widen into the output type without an additional cast op.
+        pipeline
+            .scalar_ops
+            .push((ScalarOp::cast(target_ptype), None));
+        Ok(pipeline)
+    }
+
     fn walk_runend(
         &mut self,
         array: ArrayRef,
@@ -836,16 +878,45 @@ impl FusedPlan {
         // into smem (reinterpret_cast<T*>), so we must allocate at least
         // output_elem_bytes per element — even if the stage's final ptype
         // is narrower. Otherwise the writes overflow into the next region.
+        let stage_bytes = Self::smem_stage_bytes(&spec, len, self.output_elem_bytes);
+        self.stages.push((spec, smem_byte_offset, len));
+        self.smem_byte_cursor += stage_bytes;
+        smem_byte_offset
+    }
+
+    fn smem_stage_bytes(spec: &Stage, len: u32, output_elem_bytes: u32) -> u32 {
         let final_ptype = spec
             .scalar_ops
             .last()
             .map(|(op, _)| op.output_ptype)
             .unwrap_or(spec.source_ptype);
         let final_elem_bytes = tag_to_ptype(final_ptype).byte_width() as u32;
-        let elem_bytes = final_elem_bytes.max(self.output_elem_bytes);
-        let stage_bytes = len * elem_bytes;
-        self.stages.push((spec, smem_byte_offset, len));
-        self.smem_byte_cursor += stage_bytes;
-        smem_byte_offset
+        len * final_elem_bytes.max(output_elem_bytes)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex::array::IntoArray;
+    use vortex::array::arrays::PrimitiveArray;
+    use vortex::array::builtins::ArrayBuiltins;
+    use vortex::dtype::DType;
+    use vortex::dtype::Nullability;
+
+    use super::*;
+
+    #[test]
+    fn cast_to_non_primitive_target_is_not_dyn_dispatch_compatible() -> VortexResult<()> {
+        let cast = PrimitiveArray::from_iter([0u8, 1])
+            .into_array()
+            .cast(DType::Bool(Nullability::NonNullable))?;
+
+        assert!(!is_dyn_dispatch_cast_compatible(&cast));
+        assert!(matches!(
+            DispatchPlan::new(&cast, CudaDispatchMode::DynDispatchOnly)?,
+            DispatchPlan::Unfused
+        ));
+
+        Ok(())
     }
 }
diff --git a/vortex-cuda/src/executor.rs b/vortex-cuda/src/executor.rs
index aa18cc30899..069941c266c 100644
--- a/vortex-cuda/src/executor.rs
+++ b/vortex-cuda/src/executor.rs
@@ -21,8 +21,11 @@ use vortex::array::ArrayVTable;
 use vortex::array::Canonical;
 use vortex::array::ExecutionCtx;
 use vortex::array::IntoArray;
+use vortex::array::arrays::Extension;
+use vortex::array::arrays::ExtensionArray;
 use vortex::array::arrays::Struct;
 use vortex::array::arrays::StructArray;
+use vortex::array::arrays::extension::ExtensionArrayExt;
 use vortex::array::arrays::struct_::StructDataParts;
 use vortex::array::buffer::BufferHandle;
 use vortex::dtype::PType;
@@ -412,6 +415,18 @@ impl CudaArrayExt for ArrayRef {
             )));
         }
 
+        // Extension arrays match AnyCanonical regardless of how their storage
+        // is encoded, so the canonical early-return below would skip them with
+        // the storage still compressed. Recurse into the storage so compressed
+        // storage decodes on the GPU.
+        if let Some(ext) = self.as_opt::<Extension>() {
+            let storage = ext.storage_array().clone().execute_cuda(ctx).await?;
+            return Ok(Canonical::Extension(ExtensionArray::new(
+                ext.ext_dtype().clone(),
+                storage.into_array(),
+            )));
+        }
+
         if self.is_canonical() || self.is_empty() {
             trace!(encoding = ?self.encoding_id(), "skipping canonical");
             return self.execute(&mut ctx.ctx);
diff --git a/vortex-cuda/src/hybrid_dispatch/mod.rs b/vortex-cuda/src/hybrid_dispatch/mod.rs
index eb0727e992f..9f5fde8b502 100644
--- a/vortex-cuda/src/hybrid_dispatch/mod.rs
+++ b/vortex-cuda/src/hybrid_dispatch/mod.rs
@@ -151,24 +151,47 @@ pub async fn try_gpu_dispatch(
 
 #[cfg(test)]
 mod tests {
+    use rstest::rstest;
+    use vortex::array::ArrayRef;
     use vortex::array::IntoArray;
+    use vortex::array::arrays::ExtensionArray;
     use vortex::array::arrays::PrimitiveArray;
+    use vortex::array::arrays::extension::ExtensionArrayExt;
     use vortex::array::assert_arrays_eq;
+    use vortex::array::extension::datetime::Date;
+    use vortex::array::extension::datetime::TimeUnit;
+    use vortex::array::extension::datetime::Timestamp;
     use vortex::array::validity::Validity::NonNullable;
     use vortex::buffer::Buffer;
+    use vortex::dtype::NativePType;
+    use vortex::dtype::Nullability;
     use vortex::encodings::fastlanes::BitPacked;
     use vortex::encodings::fastlanes::FoR;
     use vortex::error::VortexExpect;
     use vortex::error::VortexResult;
     use vortex::mask::Mask;
+    use vortex::scalar::Scalar;
     use vortex::session::VortexSession;
     use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
 
     use crate::CanonicalCudaExt;
+    use crate::canonicalize_cpu;
     use crate::executor::CudaArrayExt;
     use crate::session::CudaSession;
 
+    fn for_bp<T: NativePType + Into<Scalar>>(values: Vec<T>, reference: T) -> ArrayRef {
+        let bp = BitPacked::encode(
+            &PrimitiveArray::new(Buffer::from(values), NonNullable).into_array(),
+            7,
+            &mut LEGACY_SESSION.create_execution_ctx(),
+        )
+        .vortex_expect("bp");
+        FoR::try_new(bp.into_array(), reference.into())
+            .vortex_expect("for")
+            .into_array()
+    }
+
     /// FoR(BitPacked) u32 — entire tree compiles into a single fused plan.
     #[crate::test]
     async fn test_fused() -> VortexResult<()> {
@@ -183,7 +206,7 @@ mod tests {
         .vortex_expect("bp");
         let arr = FoR::try_new(bp.into_array(), 1000u32.into()).vortex_expect("for");
 
-        let cpu = crate::canonicalize_cpu(arr.clone())?.into_array();
+        let cpu = canonicalize_cpu(arr.clone())?.into_array();
         let gpu = arr
             .into_array()
             .execute_cuda(&mut ctx)
@@ -219,7 +242,7 @@ mod tests {
             None,
         )?;
 
-        let cpu = crate::canonicalize_cpu(alp.clone())?.into_array();
+        let cpu = canonicalize_cpu(alp.clone())?.into_array();
         let gpu = alp
             .into_array()
             .execute_cuda(&mut ctx)
@@ -257,7 +280,7 @@ mod tests {
         .unwrap();
         let arr = ALP::try_new(encoded, Exponents { e: 0, f: 2 }, Some(patches))?;
 
-        let cpu = crate::canonicalize_cpu(arr.clone())?.into_array();
+        let cpu = canonicalize_cpu(arr.clone())?.into_array();
         let gpu = arr
             .into_array()
             .execute_cuda(&mut ctx)
@@ -366,4 +389,62 @@ mod tests {
         assert_arrays_eq!(cpu, gpu);
         Ok(())
     }
+
+    /// Ext(FoR(BitPacked)) — extension-typed columns must decode their
+    /// compressed storage on the GPU instead of being treated as already
+    /// canonical (#8143).
+    #[rstest]
+    #[case::date(ExtensionArray::new(
+        Date::new(TimeUnit::Days, Nullability::NonNullable).erased(),
+        for_bp((0..2048i32).map(|i| i % 128).collect(), 10_000i32),
+    ))]
+    #[case::timestamp(ExtensionArray::new(
+        Timestamp::new(TimeUnit::Microseconds, Nullability::NonNullable).erased(),
+        for_bp((0..2048i64).map(|i| i % 128).collect(), 1_000_000i64),
+    ))]
+    #[crate::test]
+    async fn test_ext_storage_gpu_decode(#[case] ext: ExtensionArray) -> VortexResult<()> {
+        let mut ctx =
+            CudaSession::create_execution_ctx(&VortexSession::empty()).vortex_expect("ctx");
+
+        let expected_storage = canonicalize_cpu(ext.storage_array().clone())?.into_array();
+        let expected = ExtensionArray::new(ext.ext_dtype().clone(), expected_storage).into_array();
+
+        let actual = ext.into_array().execute_cuda(&mut ctx).await?;
+        let storage = actual.as_extension().storage_array();
+        assert!(
+            storage.is_canonical(),
+            "storage still encoded as {}",
+            storage.encoding_id()
+        );
+        assert!(!storage.is_host(), "storage was not decoded on the device");
+
+        let actual = actual.into_host().await?.into_array();
+        assert_arrays_eq!(expected, actual);
+        Ok(())
+    }
+
+    /// Extension over already-canonical storage executes unchanged.
+    #[crate::test]
+    async fn test_ext_canonical_storage() -> VortexResult<()> {
+        let mut ctx =
+            CudaSession::create_execution_ctx(&VortexSession::empty()).vortex_expect("ctx");
+
+        let ext = ExtensionArray::new(
+            Date::new(TimeUnit::Days, Nullability::NonNullable).erased(),
+            PrimitiveArray::new(Buffer::from((0..128i32).collect::<Vec<_>>()), NonNullable)
+                .into_array(),
+        );
+
+        let actual = ext
+            .clone()
+            .into_array()
+            .execute_cuda(&mut ctx)
+            .await?
+            .into_host()
+            .await?
+            .into_array();
+        assert_arrays_eq!(ext.into_array(), actual);
+        Ok(())
+    }
 }
diff --git a/vortex-cuda/src/layout.rs b/vortex-cuda/src/layout.rs
index 5cc9106c535..20aa26e0b3b 100644
--- a/vortex-cuda/src/layout.rs
+++ b/vortex-cuda/src/layout.rs
@@ -180,6 +180,7 @@ impl VTable for CudaFlat {
         name: Arc<str>,
         segment_source: Arc<dyn SegmentSource>,
         session: &VortexSession,
+        _ctx: &vortex::layout::LayoutReaderContext,
     ) -> VortexResult<LayoutReaderRef> {
         Ok(Arc::new(CudaFlatReader {
             layout: layout.clone(),
@@ -325,7 +326,8 @@ impl LayoutReader for CudaFlatReader {
                 array = array.slice(row_range.clone())?;
             }
 
-            let array_mask = if mask.density() < EXPR_EVAL_THRESHOLD {
+            let mask_density = mask.density();
+            let array_mask = if mask_density < EXPR_EVAL_THRESHOLD {
                 let array = array.apply(&expr)?;
                 let array = array.filter(mask.clone())?;
                 let mut ctx = session.create_execution_ctx();
@@ -342,7 +344,7 @@ impl LayoutReader for CudaFlatReader {
                 "CudaFlat mask evaluation {} - {} (mask = {}) => {}",
                 name,
                 expr,
-                mask.density(),
+                mask_density,
                 array_mask.density(),
             );
 
diff --git a/vortex-cuda/src/lib.rs b/vortex-cuda/src/lib.rs
index d2227579d9f..9e9de33a288 100644
--- a/vortex-cuda/src/lib.rs
+++ b/vortex-cuda/src/lib.rs
@@ -9,6 +9,7 @@ use tracing::info;
 
 pub mod arrow;
 mod canonical;
+mod cub;
 mod device_buffer;
 mod device_read_at;
 pub mod dynamic_dispatch;
diff --git a/vortex-cuda/src/session.rs b/vortex-cuda/src/session.rs
index 4ef1736021c..f3f7a2e3a49 100644
--- a/vortex-cuda/src/session.rs
+++ b/vortex-cuda/src/session.rs
@@ -3,12 +3,15 @@
 
 use std::any::Any;
 use std::fmt::Debug;
+use std::panic::AssertUnwindSafe;
+use std::panic::catch_unwind;
 use std::sync::Arc;
 
 use cudarc::driver::CudaContext;
 use vortex::array::ArrayId;
 use vortex::array::VortexSessionExecute;
 use vortex::error::VortexResult;
+use vortex::error::vortex_err;
 use vortex::session::Ref;
 use vortex::session::SessionExt;
 use vortex::session::SessionVar;
@@ -63,6 +66,27 @@ impl CudaSession {
         }
     }
 
+    /// Creates a default CUDA session using device 0, with all GPU array kernels preloaded.
+    ///
+    /// Unlike [`Default::default`], this returns an error instead of panicking when CUDA cannot be
+    /// initialized.
+    pub fn try_default() -> VortexResult<Self> {
+        // cudarc panics rather than returning an error when the CUDA driver library cannot be
+        // loaded, so catch any unwind here to uphold this constructor's no-panic contract.
+        match catch_unwind(AssertUnwindSafe(|| -> VortexResult<Self> {
+            let context = CudaContext::new(0)
+                .map_err(|err| vortex_err!("failed to initialize CUDA device 0: {err}"))?;
+            let this = Self::new(context);
+            initialize_cuda(&this);
+            Ok(this)
+        })) {
+            Ok(result) => result,
+            Err(_) => Err(vortex_err!(
+                "failed to initialize CUDA: the driver library is unavailable"
+            )),
+        }
+    }
+
     /// Creates a new CUDA execution context.
     pub fn create_execution_ctx(
         vortex_session: &vortex::session::VortexSession,
@@ -140,12 +164,9 @@ impl Default for CudaSession {
     /// # Panics
     ///
     /// Panics if CUDA device 0 cannot be initialized.
+    #[expect(clippy::expect_used)]
     fn default() -> Self {
-        #[expect(clippy::expect_used)]
-        let context = CudaContext::new(0).expect("Failed to initialize CUDA device 0");
-        let this = Self::new(context);
-        initialize_cuda(&this);
-        this
+        Self::try_default().expect("Failed to initialize CUDA device 0")
     }
 }
 
diff --git a/vortex-datafusion/src/convert/exprs.rs b/vortex-datafusion/src/convert/exprs.rs
index ce6c9eb0aa8..bf273eabc52 100644
--- a/vortex-datafusion/src/convert/exprs.rs
+++ b/vortex-datafusion/src/convert/exprs.rs
@@ -16,6 +16,7 @@ use datafusion_physical_expr::ScalarFunctionExpr;
 use datafusion_physical_expr::projection::ProjectionExpr;
 use datafusion_physical_expr::projection::ProjectionExprs;
 use datafusion_physical_expr::utils::collect_columns;
+use datafusion_physical_expr_common::physical_expr::is_dynamic_physical_expr;
 use datafusion_physical_plan::expressions as df_expr;
 use itertools::Itertools;
 use vortex::dtype::DType;
@@ -129,7 +130,6 @@ impl DefaultExpressionConvertor {
             let mut result = self.convert(source_expr.as_ref())?;
             for expr in field_names {
                 let field_name = expr
-                    .as_any()
                     .downcast_ref::<df_expr::Literal>()
                     .ok_or_else(|| exec_datafusion_err!("get_field field name must be a literal"))?
                     .value()
@@ -192,7 +192,7 @@ impl ExpressionConvertor for DefaultExpressionConvertor {
     fn convert(&self, df: &dyn PhysicalExpr) -> DFResult<Expression> {
         // TODO(joe): Don't return an error when we have an unsupported node, bubble up "TRUE" as in keep
         //  for that node, up to any `and` or `or` node.
-        if let Some(binary_expr) = df.as_any().downcast_ref::<df_expr::BinaryExpr>() {
+        if let Some(binary_expr) = df.downcast_ref::<df_expr::BinaryExpr>() {
             let left = self.convert(binary_expr.left().as_ref())?;
             let right = self.convert(binary_expr.right().as_ref())?;
             let operator = try_operator_from_df(binary_expr.op())?;
@@ -200,11 +200,11 @@ impl ExpressionConvertor for DefaultExpressionConvertor {
             return Ok(Binary.new_expr(operator, [left, right]));
         }
 
-        if let Some(col_expr) = df.as_any().downcast_ref::<df_expr::Column>() {
+        if let Some(col_expr) = df.downcast_ref::<df_expr::Column>() {
             return Ok(get_item(col_expr.name().to_owned(), root()));
         }
 
-        if let Some(like) = df.as_any().downcast_ref::<df_expr::LikeExpr>() {
+        if let Some(like) = df.downcast_ref::<df_expr::LikeExpr>() {
             let child = self.convert(like.expr().as_ref())?;
             let pattern = self.convert(like.pattern().as_ref())?;
             return Ok(Like.new_expr(
@@ -216,42 +216,34 @@ impl ExpressionConvertor for DefaultExpressionConvertor {
             ));
         }
 
-        if let Some(literal) = df.as_any().downcast_ref::<df_expr::Literal>() {
+        if let Some(literal) = df.downcast_ref::<df_expr::Literal>() {
             let value = Scalar::from_df(literal.value());
             return Ok(lit(value));
         }
 
-        if let Some(cast_expr) = df.as_any().downcast_ref::<df_expr::CastExpr>() {
-            let cast_dtype = DType::from_arrow((cast_expr.cast_type(), Nullability::Nullable));
+        if let Some(cast_expr) = df.downcast_ref::<df_expr::CastExpr>() {
+            let cast_dtype = DType::from_arrow(cast_expr.target_field().as_ref());
             let child = self.convert(cast_expr.expr().as_ref())?;
             return Ok(cast(child, cast_dtype));
         }
 
-        if let Some(cast_col_expr) = df.as_any().downcast_ref::<df_expr::CastColumnExpr>() {
-            let target = cast_col_expr.target_field();
-
-            let target_dtype = DType::from_arrow((target.data_type(), target.is_nullable().into()));
-            let child = self.convert(cast_col_expr.expr().as_ref())?;
-            return Ok(cast(child, target_dtype));
-        }
-
-        if let Some(is_null_expr) = df.as_any().downcast_ref::<df_expr::IsNullExpr>() {
+        if let Some(is_null_expr) = df.downcast_ref::<df_expr::IsNullExpr>() {
             let arg = self.convert(is_null_expr.arg().as_ref())?;
             return Ok(is_null(arg));
         }
 
-        if let Some(is_not_null_expr) = df.as_any().downcast_ref::<df_expr::IsNotNullExpr>() {
+        if let Some(is_not_null_expr) = df.downcast_ref::<df_expr::IsNotNullExpr>() {
             let arg = self.convert(is_not_null_expr.arg().as_ref())?;
             return Ok(is_not_null(arg));
         }
 
-        if let Some(in_list) = df.as_any().downcast_ref::<df_expr::InListExpr>() {
+        if let Some(in_list) = df.downcast_ref::<df_expr::InListExpr>() {
             let value = self.convert(in_list.expr().as_ref())?;
             let list_elements: Vec<_> = in_list
                 .list()
                 .iter()
                 .map(|e| {
-                    if let Some(lit) = e.as_any().downcast_ref::<df_expr::Literal>() {
+                    if let Some(lit) = e.downcast_ref::<df_expr::Literal>() {
                         Ok(Scalar::from_df(lit.value()))
                     } else {
                         Err(exec_datafusion_err!("Failed to cast sub-expression"))
@@ -269,11 +261,11 @@ impl ExpressionConvertor for DefaultExpressionConvertor {
             return Ok(if in_list.negated() { not(expr) } else { expr });
         }
 
-        if let Some(scalar_fn) = df.as_any().downcast_ref::<ScalarFunctionExpr>() {
+        if let Some(scalar_fn) = df.downcast_ref::<ScalarFunctionExpr>() {
             return self.try_convert_scalar_function(scalar_fn);
         }
 
-        if let Some(case_expr) = df.as_any().downcast_ref::<df_expr::CaseExpr>() {
+        if let Some(case_expr) = df.downcast_ref::<df_expr::CaseExpr>() {
             return self.try_convert_case_expr(case_expr);
         }
 
@@ -294,8 +286,8 @@ impl ExpressionConvertor for DefaultExpressionConvertor {
         for projection_expr in source_projection.iter() {
             let r = projection_expr.expr.apply(|node| {
                 // We only pull column children of scalar functions that we can't push into the scan.
-                if let Some(scalar_fn_expr) = node.as_any().downcast_ref::<ScalarFunctionExpr>()
-                    && !can_scalar_fn_be_pushed_down(scalar_fn_expr, input_schema)
+                if let Some(scalar_fn_expr) = node.downcast_ref::<ScalarFunctionExpr>()
+                    && !can_scalar_fn_be_pushed_down(scalar_fn_expr)
                 {
                     scan_projection.extend(
                         collect_columns(node)
@@ -309,7 +301,7 @@ impl ExpressionConvertor for DefaultExpressionConvertor {
 
                 // DataFusion assumes different decimal types can be coerced.
                 // Vortex expects a perfect match so we don't push it down.
-                if let Some(binary_expr) = node.as_any().downcast_ref::<df_expr::BinaryExpr>()
+                if let Some(binary_expr) = node.downcast_ref::<df_expr::BinaryExpr>()
                     && binary_expr.op().is_numerical_operators()
                     && (is_decimal(&binary_expr.left().data_type(input_schema)?)
                         && is_decimal(&binary_expr.right().data_type(input_schema)?))
@@ -403,8 +395,13 @@ fn try_operator_from_df(value: &DFOperator) -> DFResult<Operator> {
     }
 }
 
-fn can_be_pushed_down_impl(df_expr: &Arc<dyn PhysicalExpr>, schema: &Schema) -> bool {
-    let expr = df_expr.as_any();
+fn can_be_pushed_down_impl(expr: &Arc<dyn PhysicalExpr>, schema: &Schema) -> bool {
+    // We currently do not support pushdown of dynamic expressions in DF.
+    // See issue: https://github.com/vortex-data/vortex/issues/4034
+    if is_dynamic_physical_expr(expr) {
+        return false;
+    }
+
     if let Some(binary) = expr.downcast_ref::<df_expr::BinaryExpr>() {
         can_binary_be_pushed_down(binary, schema)
     } else if let Some(col) = expr.downcast_ref::<df_expr::Column>() {
@@ -420,9 +417,6 @@ fn can_be_pushed_down_impl(df_expr: &Arc<dyn PhysicalExpr>, schema: &Schema) ->
     } else if let Some(cast_expr) = expr.downcast_ref::<df_expr::CastExpr>() {
         // CastExpr child must be an expression type that convert() can handle
         is_convertible_expr(cast_expr.expr())
-    } else if let Some(cast_col_expr) = expr.downcast_ref::<df_expr::CastColumnExpr>() {
-        // CastColumnExpr child must be an expression type that convert() can handle
-        is_convertible_expr(cast_col_expr.expr())
     } else if let Some(is_null) = expr.downcast_ref::<df_expr::IsNullExpr>() {
         can_be_pushed_down_impl(is_null.arg(), schema)
     } else if let Some(is_not_null) = expr.downcast_ref::<df_expr::IsNotNullExpr>() {
@@ -434,7 +428,7 @@ fn can_be_pushed_down_impl(df_expr: &Arc<dyn PhysicalExpr>, schema: &Schema) ->
                 .iter()
                 .all(|e| can_be_pushed_down_impl(e, schema))
     } else if let Some(scalar_fn) = expr.downcast_ref::<ScalarFunctionExpr>() {
-        can_scalar_fn_be_pushed_down(scalar_fn, schema)
+        can_scalar_fn_be_pushed_down(scalar_fn)
     } else if let Some(case_expr) = expr.downcast_ref::<df_expr::CaseExpr>() {
         can_case_be_pushed_down(case_expr, schema)
     } else if expr
@@ -444,7 +438,7 @@ fn can_be_pushed_down_impl(df_expr: &Arc<dyn PhysicalExpr>, schema: &Schema) ->
         // Assume dynamic filters can be pushed down - the child won't be specified until execution time
         true
     } else {
-        tracing::debug!(%df_expr, "DataFusion expression can't be pushed down");
+        tracing::debug!(%expr, "DataFusion expression can't be pushed down");
         false
     }
 }
@@ -452,9 +446,7 @@ fn can_be_pushed_down_impl(df_expr: &Arc<dyn PhysicalExpr>, schema: &Schema) ->
 /// Checks if an expression type is one that convert() can handle.
 /// This is less restrictive than can_be_pushed_down since it only checks
 /// expression types, not data type support.
-fn is_convertible_expr(df_expr: &Arc<dyn PhysicalExpr>) -> bool {
-    let expr = df_expr.as_any();
-
+fn is_convertible_expr(expr: &Arc<dyn PhysicalExpr>) -> bool {
     // Expression types that convert() handles
     expr.downcast_ref::<df_expr::BinaryExpr>().is_some()
         || expr.downcast_ref::<df_expr::Column>().is_some()
@@ -463,9 +455,6 @@ fn is_convertible_expr(df_expr: &Arc<dyn PhysicalExpr>) -> bool {
         || expr
             .downcast_ref::<df_expr::CastExpr>()
             .is_some_and(|e| is_convertible_expr(e.expr()))
-        || expr
-            .downcast_ref::<df_expr::CastColumnExpr>()
-            .is_some_and(|e| is_convertible_expr(e.expr()))
         || expr.downcast_ref::<df_expr::IsNullExpr>().is_some()
         || expr.downcast_ref::<df_expr::IsNotNullExpr>().is_some()
         || expr.downcast_ref::<df_expr::InListExpr>().is_some()
@@ -543,13 +532,9 @@ fn supported_data_types(dt: &DataType) -> bool {
 }
 
 /// Checks if a scalar function can be pushed down.
-/// Currently only GetFieldFunc is supported, and its arguments must also be pushable.
-fn can_scalar_fn_be_pushed_down(scalar_fn: &ScalarFunctionExpr, schema: &Schema) -> bool {
+/// Currently only GetFieldFunc is supported.
+fn can_scalar_fn_be_pushed_down(scalar_fn: &ScalarFunctionExpr) -> bool {
     ScalarFunctionExpr::try_downcast_func::<GetFieldFunc>(scalar_fn).is_some()
-        && scalar_fn
-            .args()
-            .iter()
-            .all(|arg| can_be_pushed_down_impl(arg, schema))
 }
 
 // TODO(adam): Replace with `DataType::is_decimal` once its released.
@@ -571,6 +556,8 @@ mod tests {
     use arrow_schema::Field;
     use arrow_schema::Schema;
     use arrow_schema::TimeUnit as ArrowTimeUnit;
+    use datafusion::arrow::array::AsArray;
+    use datafusion::arrow::datatypes::Int32Type;
     use datafusion_common::ScalarValue;
     use datafusion_expr::Operator as DFOperator;
     use datafusion_physical_expr::PhysicalExpr;
@@ -1036,12 +1023,7 @@ mod tests {
         let vortex_as_arrow = vortex_result.into_primitive().as_slice::<i32>().to_vec();
 
         // Convert DataFusion result to Vec for comparison
-        let df_as_arrow: Vec<i32> = df_array
-            .as_any()
-            .downcast_ref::<Int32Array>()
-            .unwrap()
-            .values()
-            .to_vec();
+        let df_as_arrow: Vec<i32> = df_array.as_primitive::<Int32Type>().values().to_vec();
 
         // Compare results
         // Expected: [0, 0, 50, 100, 100] for values [1, 5, 10, 15, 20]
diff --git a/vortex-datafusion/src/persistent/access_plan.rs b/vortex-datafusion/src/persistent/access_plan.rs
index 99583b7c0e4..ad7bf941a2c 100644
--- a/vortex-datafusion/src/persistent/access_plan.rs
+++ b/vortex-datafusion/src/persistent/access_plan.rs
@@ -43,18 +43,16 @@ pub struct VortexAccessPlan {
 }
 
 impl VortexAccessPlan {
+    /// Returns the selection, if one was set.
+    pub fn selection(&self) -> Option<&Selection> {
+        self.selection.as_ref()
+    }
+
     /// Sets the row [`Selection`] to apply when the file is opened.
     pub fn with_selection(mut self, selection: Selection) -> Self {
         self.selection = Some(selection);
         self
     }
-}
-
-impl VortexAccessPlan {
-    /// Returns the selection, if one was set.
-    pub fn selection(&self) -> Option<&Selection> {
-        self.selection.as_ref()
-    }
 
     /// Applies this access plan to a [`ScanBuilder`].
     ///
diff --git a/vortex-datafusion/src/persistent/cache.rs b/vortex-datafusion/src/persistent/cache.rs
index de632a7597d..a76574031b6 100644
--- a/vortex-datafusion/src/persistent/cache.rs
+++ b/vortex-datafusion/src/persistent/cache.rs
@@ -6,6 +6,8 @@ use vortex::file::Footer;
 use vortex::file::VortexFile;
 
 /// Cached Vortex file metadata for use with DataFusion's [`FileMetadataCache`].
+///
+/// [`FileMetadataCache`]: datafusion_execution::cache::cache_manager::FileMetadataCache
 pub struct CachedVortexMetadata {
     footer: Footer,
 }
diff --git a/vortex-datafusion/src/persistent/format.rs b/vortex-datafusion/src/persistent/format.rs
index 043f1d90342..50c7c915eda 100644
--- a/vortex-datafusion/src/persistent/format.rs
+++ b/vortex-datafusion/src/persistent/format.rs
@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use std::any::Any;
 use std::fmt::Debug;
 use std::fmt::Formatter;
 use std::sync::Arc;
@@ -295,7 +294,7 @@ impl FileFormatFactory for VortexFormatFactory {
             if let Some(key) = key.strip_prefix("format.") {
                 opts.set(key, value)?;
             } else {
-                tracing::trace!("Ignoring options '{key}'");
+                tracing::trace!("Ignoring option '{key}'");
             }
         }
 
@@ -308,10 +307,6 @@ impl FileFormatFactory for VortexFormatFactory {
     fn default(&self) -> Arc<dyn FileFormat> {
         Arc::new(VortexFormat::new(self.session.clone()))
     }
-
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
 }
 
 impl VortexFormat {
@@ -339,10 +334,6 @@ impl VortexFormat {
 
 #[async_trait]
 impl FileFormat for VortexFormat {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
     fn compression_type(&self) -> Option<FileCompressionType> {
         None
     }
@@ -603,7 +594,6 @@ impl FileFormat for VortexFormat {
     ) -> DFResult<Arc<dyn ExecutionPlan>> {
         let mut source = file_scan_config
             .file_source()
-            .as_any()
             .downcast_ref::<VortexSource>()
             .cloned()
             .ok_or_else(|| internal_datafusion_err!("Expected VortexSource"))?;
diff --git a/vortex-datafusion/src/persistent/metrics.rs b/vortex-datafusion/src/persistent/metrics.rs
index d4c6456d6fa..e3bb1b18868 100644
--- a/vortex-datafusion/src/persistent/metrics.rs
+++ b/vortex-datafusion/src/persistent/metrics.rs
@@ -73,16 +73,13 @@ impl VortexMetricsFinder {
 impl ExecutionPlanVisitor for VortexMetricsFinder {
     type Error = std::convert::Infallible;
     fn pre_visit(&mut self, plan: &dyn ExecutionPlan) -> Result<bool, Self::Error> {
-        if let Some(exec) = plan.as_any().downcast_ref::<DataSourceExec>() {
+        if let Some(exec) = plan.downcast_ref::<DataSourceExec>() {
             // Start with exec metrics or create a new set
             let mut set = exec.metrics().unwrap_or_default();
 
             // Include our own metrics from VortexSource
-            if let Some(file_scan) = exec.data_source().as_any().downcast_ref::<FileScanConfig>()
-                && let Some(scan) = file_scan
-                    .file_source
-                    .as_any()
-                    .downcast_ref::<VortexSource>()
+            if let Some(file_scan) = exec.data_source().downcast_ref::<FileScanConfig>()
+                && let Some(scan) = file_scan.file_source.downcast_ref::<VortexSource>()
             {
                 for metric in scan
                     .metrics_registry()
@@ -240,7 +237,7 @@ mod tests {
             &mut self,
             plan: &dyn datafusion_physical_plan::ExecutionPlan,
         ) -> Result<bool, Self::Error> {
-            if plan.as_any().downcast_ref::<DataSourceExec>().is_some() {
+            if plan.downcast_ref::<DataSourceExec>().is_some() {
                 self.0 += 1;
                 Ok(false)
             } else {
diff --git a/vortex-datafusion/src/persistent/opener.rs b/vortex-datafusion/src/persistent/opener.rs
index 2f17235ed19..9f062b9bdfe 100644
--- a/vortex-datafusion/src/persistent/opener.rs
+++ b/vortex-datafusion/src/persistent/opener.rs
@@ -17,6 +17,7 @@ use datafusion_datasource::PartitionedFile;
 use datafusion_datasource::TableSchema;
 use datafusion_datasource::file_stream::FileOpenFuture;
 use datafusion_datasource::file_stream::FileOpener;
+use datafusion_execution::cache::cache_manager::CachedFileMetadataEntry;
 use datafusion_execution::cache::cache_manager::FileMetadataCache;
 use datafusion_physical_expr::PhysicalExprRef;
 use datafusion_physical_expr::projection::ProjectionExprs;
@@ -129,7 +130,7 @@ impl FileOpener for VortexOpener {
         let unified_file_schema = Arc::clone(self.table_schema.file_schema());
         let batch_size = self.batch_size;
         let limit = self.limit;
-        let layout_reader = Arc::clone(&self.layout_readers);
+        let layout_readers = Arc::clone(&self.layout_readers);
         let natural_split_ranges = Arc::clone(&self.natural_split_ranges);
         let has_output_ordering = self.has_output_ordering;
         let scan_concurrency = self.scan_concurrency;
@@ -160,9 +161,7 @@ impl FileOpener for VortexOpener {
         Ok(async move {
             // Create FilePruner when we have a predicate and either dynamic expressions
             // or file statistics available. The pruner can eliminate files without
-            // opening them based on:
-            // - Partition column values (e.g., date=2024-01-01)
-            // - File-level statistics (min/max values per column)
+            // opening them based on File-level statistics (min/max values per column)
             let mut file_pruner = file_pruning_predicate
                 .filter(|p| {
                     // Only create pruner if we have dynamic expressions or file statistics
@@ -192,15 +191,21 @@ impl FileOpener for VortexOpener {
                 .with_metrics_registry(Arc::clone(&metrics_registry))
                 .with_labels(labels);
 
-            if let Some(file_metadata_cache) = file_metadata_cache
-                && let Some(entry) = file_metadata_cache.get(file.path())
-                && entry.is_valid_for(&file.object_meta)
-                && let Some(vortex_metadata) = entry
-                    .file_metadata
-                    .as_any()
-                    .downcast_ref::<CachedVortexMetadata>()
-            {
-                open_opts = open_opts.with_footer(vortex_metadata.footer().clone());
+            let cached_footer = file_metadata_cache
+                .as_ref()
+                .and_then(|cache| cache.get(file.path()))
+                .filter(|entry| entry.is_valid_for(&file.object_meta))
+                .and_then(|entry| {
+                    entry
+                        .file_metadata
+                        .as_any()
+                        .downcast_ref::<CachedVortexMetadata>()
+                        .map(|vortex_metadata| vortex_metadata.footer().clone())
+                });
+            let footer_cache_hit = cached_footer.is_some();
+
+            if let Some(footer) = cached_footer {
+                open_opts = open_opts.with_footer(footer);
             }
 
             let vxf = open_opts
@@ -208,6 +213,19 @@ impl FileOpener for VortexOpener {
                 .await
                 .map_err(|e| exec_datafusion_err!("Failed to open Vortex file {e}"))?;
 
+            // On a miss, cache the parsed footer so other partitions and later executions
+            // skip the footer fetch and parse. `infer_schema`/`infer_stats` also populate
+            // this cache, but only when planning goes through `VortexFormat`.
+            if !footer_cache_hit && let Some(cache) = &file_metadata_cache {
+                cache.put(
+                    file.path(),
+                    CachedFileMetadataEntry::new(
+                        file.object_meta.clone(),
+                        Arc::new(CachedVortexMetadata::new(&vxf)),
+                    ),
+                );
+            }
+
             // Check if there are rows in this file. If not, we can save
             // ourselves some work and return an empty stream.
             if vxf.row_count() == 0 {
@@ -285,7 +303,7 @@ impl FileOpener for VortexOpener {
             let projector = leftover_projection.make_projector(&stream_schema)?;
 
             // We share our layout readers with others partitions in the scan, so we can only need to read each layout in each file once.
-            let layout_reader = match layout_reader.entry(file.object_meta.location.clone()) {
+            let layout_reader = match layout_readers.entry(file.object_meta.location.clone()) {
                 Entry::Occupied(mut occupied_entry) => {
                     if let Some(reader) = occupied_entry.get().upgrade() {
                         tracing::trace!("reusing layout reader for {}", occupied_entry.key());
@@ -314,9 +332,7 @@ impl FileOpener for VortexOpener {
 
             let mut scan_builder = ScanBuilder::new(session.clone(), Arc::clone(&layout_reader));
 
-            if let Some(extensions) = file.extensions
-                && let Some(vortex_plan) = extensions.downcast_ref::<VortexAccessPlan>()
-            {
+            if let Some(vortex_plan) = file.extensions.get::<VortexAccessPlan>() {
                 scan_builder = vortex_plan.apply_to_builder(scan_builder);
             }
 
@@ -354,7 +370,6 @@ impl FileOpener for VortexOpener {
                     // This will only fail if the user has not configured a suitable
                     // PhysicalExprAdapterFactory on the file source to handle rewriting the
                     // expression to handle missing/reordered columns in the Vortex file.
-
                     let (pushed, unpushed): (Vec<PhysicalExprRef>, Vec<PhysicalExprRef>) =
                         split_conjunction(&f)
                             .into_iter()
@@ -570,6 +585,7 @@ mod tests {
     use datafusion::physical_expr::planner::logical2physical;
     use datafusion::physical_expr_adapter::DefaultPhysicalExprAdapterFactory;
     use datafusion::scalar::ScalarValue;
+    use datafusion_execution::cache::DefaultFilesMetadataCache;
     use datafusion_expr::Operator;
     use datafusion_physical_expr::expressions as df_expr;
     use datafusion_physical_expr::projection::ProjectionExpr;
@@ -777,6 +793,46 @@ mod tests {
         Ok(())
     }
 
+    #[tokio::test]
+    async fn test_open_populates_file_metadata_cache() -> anyhow::Result<()> {
+        let object_store = Arc::new(InMemory::new()) as Arc<dyn ObjectStore>;
+        let file_path = "cached/file.vortex";
+        let batch = record_batch!(("a", Int32, vec![Some(1), Some(2), Some(3)])).unwrap();
+        let data_size =
+            write_arrow_to_vortex(Arc::clone(&object_store), file_path, batch.clone()).await?;
+
+        let file = PartitionedFile::new(file_path.to_string(), data_size);
+        let table_schema = TableSchema::from_file_schema(batch.schema());
+
+        let cache: Arc<dyn FileMetadataCache> =
+            Arc::new(DefaultFilesMetadataCache::new(64 * 1024 * 1024));
+        let mut opener = make_opener(Arc::clone(&object_store), table_schema, None);
+        opener.file_metadata_cache = Some(Arc::clone(&cache));
+
+        // The first open misses the cache and must write the parsed footer back.
+        let stream = opener.open(file.clone())?.await?;
+        stream.try_collect::<Vec<_>>().await?;
+
+        let entry = cache
+            .get(file.path())
+            .ok_or_else(|| anyhow::anyhow!("footer was not cached after open"))?;
+        assert!(entry.is_valid_for(&file.object_meta));
+        assert!(
+            entry
+                .file_metadata
+                .as_any()
+                .downcast_ref::<CachedVortexMetadata>()
+                .is_some()
+        );
+
+        // The second open hits the cache and still returns the same data.
+        let stream = opener.open(file.clone())?.await?;
+        let data = stream.try_collect::<Vec<_>>().await?;
+        assert_eq!(data.iter().map(|rb| rb.num_rows()).sum::<usize>(), 3);
+
+        Ok(())
+    }
+
     #[rstest]
     #[tokio::test]
     async fn test_open_files_different_table_schema() -> anyhow::Result<()> {
@@ -1149,9 +1205,12 @@ mod tests {
 
         let schema = batch.schema();
         let mut file = PartitionedFile::new(file_path.to_string(), data_size);
-        file.extensions = Some(Arc::new(VortexAccessPlan::default().with_selection(
-            Selection::IncludeByIndex(Buffer::from_iter(vec![1, 3, 5, 7])),
-        )));
+        file.extensions
+            .insert(
+                VortexAccessPlan::default().with_selection(Selection::IncludeByIndex(
+                    Buffer::from_iter(vec![1, 3, 5, 7]),
+                )),
+            );
 
         let opener = make_test_opener(
             Arc::clone(&object_store),
@@ -1190,9 +1249,12 @@ mod tests {
 
         let schema = batch.schema();
         let mut file = PartitionedFile::new(file_path.to_string(), data_size);
-        file.extensions = Some(Arc::new(VortexAccessPlan::default().with_selection(
-            Selection::ExcludeByIndex(Buffer::from_iter(vec![0, 2, 4, 6, 8])),
-        )));
+        file.extensions
+            .insert(
+                VortexAccessPlan::default().with_selection(Selection::ExcludeByIndex(
+                    Buffer::from_iter(vec![0, 2, 4, 6, 8]),
+                )),
+            );
 
         let opener = make_test_opener(
             Arc::clone(&object_store),
@@ -1234,9 +1296,8 @@ mod tests {
 
         let schema = batch.schema();
         let mut file = PartitionedFile::new(file_path.to_string(), data_size);
-        file.extensions = Some(Arc::new(
-            VortexAccessPlan::default().with_selection(Selection::All),
-        ));
+        file.extensions
+            .insert(VortexAccessPlan::default().with_selection(Selection::All));
 
         let opener = make_test_opener(
             Arc::clone(&object_store),
diff --git a/vortex-datafusion/src/persistent/reader.rs b/vortex-datafusion/src/persistent/reader.rs
index de221c28ca7..357b7531dce 100644
--- a/vortex-datafusion/src/persistent/reader.rs
+++ b/vortex-datafusion/src/persistent/reader.rs
@@ -1,8 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-//! Factory for creating [`VortexReadAt`][vortex::io::VortexReadAt] instances
-//! from [`PartitionedFile`]s.
+//! Factory for creating [`VortexReadAt`] instances from [`PartitionedFile`]s.
 
 use std::fmt::Debug;
 use std::sync::Arc;
@@ -72,7 +71,7 @@ impl VortexReaderFactory for DefaultVortexReaderFactory {
     ) -> DFResult<Arc<dyn VortexReadAt>> {
         Ok(Arc::new(ObjectStoreReadAt::new_with_allocator(
             Arc::clone(&self.object_store),
-            file.path().as_ref().into(),
+            file.path().clone(),
             session.handle(),
             session.allocator(),
         )) as _)
diff --git a/vortex-datafusion/src/persistent/sink.rs b/vortex-datafusion/src/persistent/sink.rs
index b9954e45e2f..55dce065188 100644
--- a/vortex-datafusion/src/persistent/sink.rs
+++ b/vortex-datafusion/src/persistent/sink.rs
@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use std::any::Any;
 use std::sync::Arc;
 
 use arrow_schema::Schema;
@@ -170,10 +169,6 @@ impl DisplayAs for VortexSink {
 
 #[async_trait]
 impl DataSink for VortexSink {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
     fn metrics(&self) -> Option<MetricsSet> {
         None
     }
diff --git a/vortex-datafusion/src/persistent/source.rs b/vortex-datafusion/src/persistent/source.rs
index aed2024d5d9..086c75adda7 100644
--- a/vortex-datafusion/src/persistent/source.rs
+++ b/vortex-datafusion/src/persistent/source.rs
@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use std::any::Any;
 use std::fmt::Formatter;
 use std::ops::Range;
 use std::sync::Arc;
@@ -14,13 +13,16 @@ use datafusion_datasource::file::FileSource;
 use datafusion_datasource::file_scan_config::FileScanConfig;
 use datafusion_datasource::file_stream::FileOpener;
 use datafusion_execution::cache::cache_manager::FileMetadataCache;
+use datafusion_physical_expr::EquivalenceProperties;
 use datafusion_physical_expr::PhysicalExprRef;
+use datafusion_physical_expr::PhysicalSortExpr;
 use datafusion_physical_expr::conjunction;
 use datafusion_physical_expr::projection::ProjectionExprs;
 use datafusion_physical_expr_adapter::DefaultPhysicalExprAdapterFactory;
 use datafusion_physical_expr_common::physical_expr::fmt_sql;
 use datafusion_physical_plan::DisplayFormatType;
 use datafusion_physical_plan::PhysicalExpr;
+use datafusion_physical_plan::SortOrderPushdownResult;
 use datafusion_physical_plan::filter_pushdown::FilterPushdownPropagation;
 use datafusion_physical_plan::filter_pushdown::PushedDown;
 use datafusion_physical_plan::filter_pushdown::PushedDownPredicate;
@@ -190,6 +192,7 @@ pub struct VortexSource {
     natural_split_ranges: Arc<DashMap<Path, Arc<[Range<u64>]>>>,
     expression_convertor: Arc<dyn ExpressionConvertor>,
     pub(crate) vortex_reader_factory: Option<Arc<dyn VortexReaderFactory>>,
+    pub(crate) ordered: bool,
     vx_metrics_registry: Arc<dyn MetricsRegistry>,
     file_metadata_cache: Option<Arc<dyn FileMetadataCache>>,
     /// Whether to enable expression pushdown into the underlying Vortex scan.
@@ -224,6 +227,7 @@ impl VortexSource {
             vortex_reader_factory: None,
             vx_metrics_registry: Arc::new(DefaultMetricsRegistry::default()),
             file_metadata_cache: None,
+            ordered: false,
             options: VortexTableOptions::default(),
         }
     }
@@ -336,7 +340,7 @@ impl VortexSource {
             metrics_registry: Arc::clone(&self.vx_metrics_registry),
             layout_readers: Arc::clone(&self.layout_readers),
             natural_split_ranges: Arc::clone(&self.natural_split_ranges),
-            has_output_ordering: !base_config.output_ordering.is_empty(),
+            has_output_ordering: !base_config.output_ordering.is_empty() || self.ordered,
             expression_convertor: Arc::clone(&self.expression_convertor),
             file_metadata_cache: self.file_metadata_cache.clone(),
             projection_pushdown: self.options.projection_pushdown,
@@ -361,10 +365,6 @@ impl FileSource for VortexSource {
         )?))
     }
 
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
     fn with_batch_size(&self, batch_size: usize) -> Arc<dyn FileSource> {
         let mut source = self.clone();
         source.batch_size = Some(batch_size);
@@ -383,6 +383,27 @@ impl FileSource for VortexSource {
         VORTEX_FILE_EXTENSION
     }
 
+    fn try_pushdown_sort(
+        &self,
+        order: &[PhysicalSortExpr],
+        eq_properties: &EquivalenceProperties,
+    ) -> DFResult<SortOrderPushdownResult<Arc<dyn FileSource>>> {
+        if order.is_empty() {
+            return Ok(SortOrderPushdownResult::Unsupported);
+        }
+
+        if eq_properties.ordering_satisfy(order.iter().cloned())? {
+            let mut this = self.clone();
+            this.ordered = true;
+
+            return Ok(SortOrderPushdownResult::Exact {
+                inner: Arc::new(this) as Arc<dyn FileSource>,
+            });
+        }
+
+        Ok(SortOrderPushdownResult::Unsupported)
+    }
+
     fn fmt_extra(&self, t: DisplayFormatType, f: &mut Formatter) -> std::fmt::Result {
         match t {
             DisplayFormatType::Default | DisplayFormatType::Verbose => {
@@ -498,6 +519,7 @@ mod tests {
     use arrow_schema::Schema;
     use datafusion_datasource::file_scan_config::FileScanConfigBuilder;
     use datafusion_execution::object_store::ObjectStoreUrl;
+    use datafusion_physical_expr::expressions::Column;
     use object_store::memory::InMemory;
     use vortex::VortexSessionDefault;
 
@@ -537,6 +559,53 @@ mod tests {
         }
     }
 
+    fn sort_column(name: &str, index: usize) -> PhysicalSortExpr {
+        let expr: PhysicalExprRef = Arc::new(Column::new(name, index));
+        PhysicalSortExpr::new_default(expr)
+    }
+
+    fn sort_test_schema() -> Arc<Schema> {
+        Arc::new(Schema::new(vec![
+            Field::new("a", DataType::Int32, false),
+            Field::new("b", DataType::Int32, false),
+        ]))
+    }
+
+    fn sort_test_source(schema: Arc<Schema>) -> VortexSource {
+        VortexSource::new(
+            TableSchema::from_file_schema(schema),
+            VortexSession::default(),
+        )
+    }
+
+    fn assert_ordered_source(inner: Arc<dyn FileSource>) -> anyhow::Result<()> {
+        let source = inner
+            .downcast_ref::<VortexSource>()
+            .ok_or_else(|| anyhow::anyhow!("expected VortexSource"))?;
+
+        assert!(source.ordered);
+        Ok(())
+    }
+
+    #[test]
+    fn try_pushdown_sort_returns_exact_when_ordering_is_satisfied() -> anyhow::Result<()> {
+        let schema = sort_test_schema();
+        let source = sort_test_source(Arc::clone(&schema));
+        let order = vec![sort_column("a", 0), sort_column("b", 1)];
+        let eq_properties = EquivalenceProperties::new_with_orderings(schema, [order.clone()]);
+
+        let result = source.try_pushdown_sort(&order, &eq_properties)?;
+
+        match result {
+            SortOrderPushdownResult::Exact { inner } => assert_ordered_source(inner)?,
+            SortOrderPushdownResult::Inexact { .. } | SortOrderPushdownResult::Unsupported => {
+                anyhow::bail!("expected exact sort pushdown")
+            }
+        }
+        assert!(!source.ordered);
+        Ok(())
+    }
+
     #[test]
     fn create_vortex_opener_preserves_expression_convertor() -> anyhow::Result<()> {
         let file_schema = Arc::new(Schema::new(vec![Field::new("a", DataType::Int32, false)]));
diff --git a/vortex-datafusion/src/persistent/stream.rs b/vortex-datafusion/src/persistent/stream.rs
index 52d9b7daecc..af2fbc8693e 100644
--- a/vortex-datafusion/src/persistent/stream.rs
+++ b/vortex-datafusion/src/persistent/stream.rs
@@ -12,7 +12,9 @@ use futures::Stream;
 use futures::StreamExt;
 use futures::stream::BoxStream;
 
-/// Utility to end a stream early if its backing [`PartitionFile`] can be pruned away by an updated dynamic expression.
+/// Utility to end a stream early if its backing [`PartitionedFile`] can be pruned away by an updated dynamic expression.
+///
+/// [`PartitionedFile`]: datafusion_datasource::PartitionedFile
 pub(crate) struct PrunableStream {
     file_pruner: FilePruner,
     stream: BoxStream<'static, DFResult<RecordBatch>>,
diff --git a/vortex-datafusion/src/v2/source.rs b/vortex-datafusion/src/v2/source.rs
index ffb7c068c1e..82fae9bf56d 100644
--- a/vortex-datafusion/src/v2/source.rs
+++ b/vortex-datafusion/src/v2/source.rs
@@ -67,7 +67,6 @@
 //! [`DataSourceRef`]: vortex::scan::DataSourceRef
 //! [`ScanRequest`]: vortex::scan::ScanRequest
 
-use std::any::Any;
 use std::fmt;
 use std::fmt::Formatter;
 use std::sync::Arc;
@@ -469,10 +468,6 @@ impl DataSource for VortexDataSource {
         )))
     }
 
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
     fn fmt_as(&self, _t: DisplayFormatType, f: &mut Formatter) -> fmt::Result {
         write!(
             f,
@@ -509,7 +504,7 @@ impl DataSource for VortexDataSource {
         EquivalenceProperties::new(Arc::clone(&self.leftover_schema))
     }
 
-    fn partition_statistics(&self, _partition: Option<usize>) -> DFResult<Statistics> {
+    fn partition_statistics(&self, _partition: Option<usize>) -> DFResult<Arc<Statistics>> {
         // FIXME(ngates): this should be adjusted based on filters. See DuckDB for heuristics,
         //  and in the future, store the selectivity stats in the session.
         let num_rows = estimate_to_df_precision(&self.data_source.row_count());
@@ -521,11 +516,11 @@ impl DataSource for VortexDataSource {
         // from the initial schema after try_swapping_with_projection adds computed columns.
         let column_statistics = self.leftover_statistics.clone();
 
-        Ok(Statistics {
+        Ok(Arc::new(Statistics {
             num_rows,
             total_byte_size,
             column_statistics,
-        })
+        }))
     }
 
     fn with_fetch(&self, limit: Option<usize>) -> Option<Arc<dyn DataSource>> {
diff --git a/vortex-datafusion/src/v2/table.rs b/vortex-datafusion/src/v2/table.rs
index c45a25c8b91..b881eb025ab 100644
--- a/vortex-datafusion/src/v2/table.rs
+++ b/vortex-datafusion/src/v2/table.rs
@@ -7,7 +7,6 @@
 //! [`DataSourceRef`]: vortex::scan::DataSourceRef
 //! [`TableProvider`]: datafusion_catalog::TableProvider
 
-use std::any::Any;
 use std::fmt;
 use std::sync::Arc;
 
@@ -107,10 +106,6 @@ impl VortexTable {
 
 #[async_trait]
 impl TableProvider for VortexTable {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
     fn schema(&self) -> SchemaRef {
         Arc::clone(&self.arrow_schema)
     }
diff --git a/vortex-duckdb/Cargo.toml b/vortex-duckdb/Cargo.toml
index 0f5e6b4797e..7dc239a4b1a 100644
--- a/vortex-duckdb/Cargo.toml
+++ b/vortex-duckdb/Cargo.toml
@@ -40,16 +40,19 @@ tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 url = { workspace = true }
 vortex = { workspace = true, features = ["files", "tokio", "object_store"] }
+vortex-geo = { workspace = true }
 vortex-utils = { workspace = true, features = ["dashmap"] }
 
 [dev-dependencies]
 anyhow = { workspace = true }
+geo-types = { workspace = true }
 jiff = { workspace = true }
 rstest = { workspace = true }
 tempfile = { workspace = true }
 vortex-array = { workspace = true, features = ["_test-harness"] }
 vortex-runend = { workspace = true }
 vortex-sequence = { workspace = true }
+wkb = { workspace = true }
 
 [lints]
 workspace = true
diff --git a/vortex-duckdb/build.rs b/vortex-duckdb/build.rs
index 3451af771bc..0ed297c6637 100644
--- a/vortex-duckdb/build.rs
+++ b/vortex-duckdb/build.rs
@@ -397,17 +397,40 @@ fn cbindgen_rust2c(crate_dir: &Path) {
 }
 
 fn main() {
-    println!("cargo:rerun-if-env-changed=DUCKDB_VERSION");
+    println!("cargo:rerun-if-changed=cpp/include");
     println!("cargo:rerun-if-env-changed=VX_DUCKDB_DEBUG");
     println!("cargo:rerun-if-env-changed=VX_DUCKDB_SAN");
     println!("cargo:rerun-if-env-changed=CARGO_HTTP_TIMEOUT");
     println!("cargo:rerun-if-env-changed=HTTP_TIMEOUT");
     println!("cargo:rerun-if-env-changed=TARGET");
 
-    // `DUCKDB_VERSION` is set by the extension build in CI.
-    // This is to ensure we don't implicitly build against a different DuckDB
-    // version during an extension build which might lead to subtle ABI breaks,
-    // e.g. reordering fields in C++ structs.
+    // These two variables are set in duckdb-vortex's CI. Don't download
+    // duckdb if they are present
+    println!("cargo:rerun-if-env-changed=DUCKDB_SOURCE_DIR");
+    println!("cargo:rerun-if-env-changed=DUCKDB_VERSION");
+
+    // sanity check that either none or both are provided
+    assert_eq!(
+        env::var("DUCKDB_VERSION").is_ok(),
+        env::var("DUCKDB_SOURCE_DIR").is_ok()
+    );
+    // If variables are not set, we are either running locally or
+    // in vortex's CI.
+
+    let crate_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
+    if let Some(source_dir) = env::var_os("DUCKDB_SOURCE_DIR") {
+        let source_dir = PathBuf::from(source_dir);
+        let duckdb_include_dir = source_dir.join("src").join("include");
+        println!(
+            "cargo:info=Using DuckDB source from DUCKDB_SOURCE_DIR={}",
+            source_dir.display()
+        );
+        bindgen_c2rust(&crate_dir, &duckdb_include_dir);
+        cbindgen_rust2c(&crate_dir);
+        compile_cpp(&duckdb_include_dir);
+        return;
+    }
+
     let version = env::var("DUCKDB_VERSION")
         // You can also change this version to a commit hash
         .unwrap_or_else(|_| DEFAULT_DUCKDB_VERSION.to_owned());
@@ -417,7 +440,6 @@ fn main() {
         DuckDBVersion::Commit(c) => println!("cargo:info=Using DuckDB commit: {c}"),
     }
 
-    let crate_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
     let duckdb_dir = crate_dir.join("duckdb");
     let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
     let library_dir = out_dir.join(format!("duckdb-lib-{version}"));
@@ -486,7 +508,6 @@ fn main() {
     };
 
     let duckdb_include_dir = inner_dir.join("src").join("include");
-    println!("cargo:rerun-if-changed=cpp/include");
     bindgen_c2rust(&crate_dir, &duckdb_include_dir);
     cbindgen_rust2c(&crate_dir);
     compile_cpp(&duckdb_include_dir);
diff --git a/vortex-duckdb/cpp/include/duckdb_vx/logical_type.h b/vortex-duckdb/cpp/include/duckdb_vx/logical_type.h
index 66d721effb7..a4b89c87550 100644
--- a/vortex-duckdb/cpp/include/duckdb_vx/logical_type.h
+++ b/vortex-duckdb/cpp/include/duckdb_vx/logical_type.h
@@ -12,6 +12,10 @@ extern "C" {
 char *duckdb_vx_logical_type_stringify(duckdb_logical_type ty);
 duckdb_logical_type duckdb_vx_logical_type_copy(duckdb_logical_type ty);
 
+/// Creates a GEOMETRY logical type with the given CRS (Coordinate Reference System).
+/// `crs` must be a NUL-terminated UTF-8 string. Pass an empty string for no CRS.
+duckdb_logical_type duckdb_vx_create_geometry(const char *crs);
+
 #ifdef __cplusplus /* End C ABI */
 }
 #endif
diff --git a/vortex-duckdb/cpp/include/duckdb_vx/value.h b/vortex-duckdb/cpp/include/duckdb_vx/value.h
index 34c38b50c11..cc02d78e128 100644
--- a/vortex-duckdb/cpp/include/duckdb_vx/value.h
+++ b/vortex-duckdb/cpp/include/duckdb_vx/value.h
@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include "duckdb.h"
+
 #ifdef __cplusplus /* If compiled as C++, use C ABI */
 extern "C" {
 #endif
@@ -10,6 +12,19 @@ extern "C" {
 // Create a null value with a reference to a logical type.
 duckdb_value duckdb_vx_value_create_null(duckdb_logical_type ty);
 
+/// Creates a GEOMETRY value containing the given WKB bytes and CRS.
+///
+/// `wkb` points to `len` bytes of well-known-binary geometry data; the bytes are not validated.
+/// `crs` must be a NUL-terminated UTF-8 string; pass NULL or an empty string for no CRS.
+duckdb_value duckdb_vx_value_create_geometry(const uint8_t *wkb, idx_t len, const char *crs);
+
+/// Extracts the raw WKB bytes from a GEOMETRY value as a duckdb_blob.
+///
+/// This bypasses the GEOMETRY -> BLOB default cast (which would require the spatial extension to
+/// be loaded). The returned `data` pointer must be freed with `duckdb_free`. Returns `{nullptr, 0}`
+/// if `value` is null or not a GEOMETRY value.
+duckdb_blob duckdb_vx_value_get_geometry(duckdb_value value);
+
 #ifdef __cplusplus /* End C ABI */
 }
 #endif
diff --git a/vortex-duckdb/cpp/logical_type.cpp b/vortex-duckdb/cpp/logical_type.cpp
index fec7f80e83f..d21896ddc4d 100644
--- a/vortex-duckdb/cpp/logical_type.cpp
+++ b/vortex-duckdb/cpp/logical_type.cpp
@@ -4,6 +4,7 @@
 #include "duckdb_vx/logical_type.h"
 #include "duckdb/common/types.hpp"
 #include <cassert>
+#include <string>
 
 duckdb_logical_type duckdb_vx_logical_type_copy(duckdb_logical_type ty) {
     D_ASSERT(ty);
@@ -19,3 +20,11 @@ char *duckdb_vx_logical_type_stringify(duckdb_logical_type c_type) {
     memcpy(result, str.c_str(), str.size() + 1);
     return result;
 }
+
+duckdb_logical_type duckdb_vx_create_geometry(const char *crs) {
+    D_ASSERT(crs);
+    auto geom =
+        (*crs == '\0') ? duckdb::LogicalType::GEOMETRY() : duckdb::LogicalType::GEOMETRY(std::string(crs));
+    auto copy = duckdb::make_uniq<duckdb::LogicalType>(std::move(geom));
+    return reinterpret_cast<duckdb_logical_type>(copy.release());
+}
diff --git a/vortex-duckdb/cpp/value.cpp b/vortex-duckdb/cpp/value.cpp
index 8a0772a2650..9a3154a43a0 100644
--- a/vortex-duckdb/cpp/value.cpp
+++ b/vortex-duckdb/cpp/value.cpp
@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+#include "duckdb/common/types/geometry_crs.hpp"
 #include "duckdb/common/types/value.hpp"
 
 #include "duckdb_vx.h"
@@ -10,3 +11,30 @@ extern "C" duckdb_value duckdb_vx_value_create_null(duckdb_logical_type ty) {
     auto value = duckdb::make_uniq<duckdb::Value>(*logical_type);
     return reinterpret_cast<duckdb_value>(value.release());
 }
+
+extern "C" duckdb_value duckdb_vx_value_create_geometry(const uint8_t *wkb, idx_t len, const char *crs) {
+    const auto bytes = reinterpret_cast<duckdb::const_data_ptr_t>(wkb);
+    auto value =
+        (crs == nullptr || *crs == '\0')
+            ? duckdb::Value::GEOMETRY(bytes, len)
+            : duckdb::Value::GEOMETRY(bytes, len, duckdb::CoordinateReferenceSystem(std::string(crs)));
+    auto owned = duckdb::make_uniq<duckdb::Value>(std::move(value));
+    return reinterpret_cast<duckdb_value>(owned.release());
+}
+
+extern "C" duckdb_blob duckdb_vx_value_get_geometry(duckdb_value value) {
+    if (value == nullptr) {
+        return {nullptr, 0};
+    }
+    const auto val = reinterpret_cast<duckdb::Value *>(value);
+    if (val->type().id() != duckdb::LogicalTypeId::GEOMETRY) {
+        return {nullptr, 0};
+    }
+    const auto &str = duckdb::StringValue::Get(*val);
+    const auto size = str.size();
+    auto buf = reinterpret_cast<void *>(duckdb_malloc(size));
+    if (size > 0) {
+        memcpy(buf, str.c_str(), size);
+    }
+    return {buf, size};
+}
diff --git a/vortex-duckdb/src/convert/dtype.rs b/vortex-duckdb/src/convert/dtype.rs
index 4d9d0be4fee..4238b354182 100644
--- a/vortex-duckdb/src/convert/dtype.rs
+++ b/vortex-duckdb/src/convert/dtype.rs
@@ -31,6 +31,7 @@
 use std::ffi::CString;
 use std::sync::Arc;
 
+use vortex::array::dtype::extension::ExtDType;
 use vortex::dtype::DType;
 use vortex::dtype::DecimalDType;
 use vortex::dtype::Nullability;
@@ -56,6 +57,8 @@ use vortex::extension::datetime::TemporalMetadata;
 use vortex::extension::datetime::Time;
 use vortex::extension::datetime::TimeUnit;
 use vortex::extension::datetime::Timestamp;
+use vortex_geo::extension::GeoMetadata;
+use vortex_geo::extension::WellKnownBinary;
 
 use crate::cpp::DUCKDB_TYPE;
 use crate::duckdb::LogicalType;
@@ -159,6 +162,16 @@ impl FromLogicalType for DType {
                     .collect::<VortexResult<_>>()?,
                 nullability,
             ),
+            DUCKDB_TYPE::DUCKDB_TYPE_GEOMETRY => {
+                let crs = logical_type.geometry_crs().map(|crs| crs.to_string());
+                DType::Extension(
+                    ExtDType::<WellKnownBinary>::try_new(
+                        GeoMetadata { crs },
+                        DType::Binary(nullability),
+                    )?
+                    .erased(),
+                )
+            }
             DUCKDB_TYPE::DUCKDB_TYPE_VARIANT => DType::Variant(nullability),
             DUCKDB_TYPE::DUCKDB_TYPE_TIME_TZ => todo!(),
             DUCKDB_TYPE::DUCKDB_TYPE_INTERVAL => todo!(),
@@ -171,7 +184,6 @@ impl FromLogicalType for DType {
             DUCKDB_TYPE::DUCKDB_TYPE_BIGNUM => todo!(),
             DUCKDB_TYPE::DUCKDB_TYPE_STRING_LITERAL => todo!(),
             DUCKDB_TYPE::DUCKDB_TYPE_INTEGER_LITERAL => todo!(),
-            DUCKDB_TYPE::DUCKDB_TYPE_GEOMETRY => todo!(),
         })
     }
 }
@@ -228,40 +240,17 @@ impl TryFrom<&DType> for LogicalType {
                 vortex_bail!("Vortex Variant array aren't supported in DuckDB")
             }
             DType::Extension(ext_dtype) => {
-                let Some(temporal) = ext_dtype.metadata_opt::<AnyTemporal>() else {
-                    vortex_bail!("Unsupported extension type \"{}\"", ext_dtype.id());
-                };
-
-                match temporal {
-                    TemporalMetadata::Timestamp(unit, None) => match unit {
-                        TimeUnit::Nanoseconds => DUCKDB_TYPE::DUCKDB_TYPE_TIMESTAMP_NS,
-                        TimeUnit::Microseconds => DUCKDB_TYPE::DUCKDB_TYPE_TIMESTAMP,
-                        TimeUnit::Milliseconds => DUCKDB_TYPE::DUCKDB_TYPE_TIMESTAMP_MS,
-                        TimeUnit::Seconds => DUCKDB_TYPE::DUCKDB_TYPE_TIMESTAMP_S,
-                        _ => vortex_bail!("Invalid TimeUnit {} for timestamp", unit),
-                    },
-                    TemporalMetadata::Timestamp(unit, Some(tz)) => {
-                        if tz.as_ref() != "UTC" {
-                            vortex_bail!("Invalid timezone for timestamp_tz {tz}, must be UTC");
-                        }
-                        if unit != &TimeUnit::Microseconds {
-                            vortex_bail!(
-                                "Invalid TimeUnit {} for timestamp_tz, must be Microseconds",
-                                unit
-                            );
-                        }
-                        DUCKDB_TYPE::DUCKDB_TYPE_TIMESTAMP_TZ
-                    }
-                    TemporalMetadata::Date(unit) => match unit {
-                        TimeUnit::Days => DUCKDB_TYPE::DUCKDB_TYPE_DATE,
-                        _ => vortex_bail!("Invalid TimeUnit {} for date", unit),
-                    },
-                    TemporalMetadata::Time(unit) => match unit {
-                        TimeUnit::Microseconds => DUCKDB_TYPE::DUCKDB_TYPE_TIME,
-                        TimeUnit::Nanoseconds => DUCKDB_TYPE::DUCKDB_TYPE_TIME_NS,
-                        _ => vortex_bail!("Invalid TimeUnit {} for time", unit),
-                    },
+                // Handle first-party extension types that have DuckDB equivalents.
+                if let Some(temporal) = ext_dtype.metadata_opt::<AnyTemporal>() {
+                    return temporal_to_duckdb(temporal);
                 }
+
+                if let Some(wkb) = ext_dtype.metadata_opt::<WellKnownBinary>() {
+                    let crs = wkb.crs.as_ref();
+                    return LogicalType::geometry_type(crs.map(|crs| crs.as_str()));
+                }
+
+                vortex_bail!("Unsupported extension type \"{}\"", ext_dtype.id());
             }
         };
 
@@ -269,6 +258,41 @@ impl TryFrom<&DType> for LogicalType {
     }
 }
 
+fn temporal_to_duckdb(temporal: TemporalMetadata) -> VortexResult<LogicalType> {
+    let duckdb_type = match temporal {
+        TemporalMetadata::Timestamp(unit, None) => match unit {
+            TimeUnit::Nanoseconds => DUCKDB_TYPE::DUCKDB_TYPE_TIMESTAMP_NS,
+            TimeUnit::Microseconds => DUCKDB_TYPE::DUCKDB_TYPE_TIMESTAMP,
+            TimeUnit::Milliseconds => DUCKDB_TYPE::DUCKDB_TYPE_TIMESTAMP_MS,
+            TimeUnit::Seconds => DUCKDB_TYPE::DUCKDB_TYPE_TIMESTAMP_S,
+            _ => vortex_bail!("Invalid TimeUnit {} for timestamp", unit),
+        },
+        TemporalMetadata::Timestamp(unit, Some(tz)) => {
+            if tz.as_ref() != "UTC" {
+                vortex_bail!("Invalid timezone for timestamp_tz {tz}, must be UTC");
+            }
+            if unit != &TimeUnit::Microseconds {
+                vortex_bail!(
+                    "Invalid TimeUnit {} for timestamp_tz, must be Microseconds",
+                    unit
+                );
+            }
+            DUCKDB_TYPE::DUCKDB_TYPE_TIMESTAMP_TZ
+        }
+        TemporalMetadata::Date(unit) => match unit {
+            TimeUnit::Days => DUCKDB_TYPE::DUCKDB_TYPE_DATE,
+            _ => vortex_bail!("Invalid TimeUnit {} for date", unit),
+        },
+        TemporalMetadata::Time(unit) => match unit {
+            TimeUnit::Microseconds => DUCKDB_TYPE::DUCKDB_TYPE_TIME,
+            TimeUnit::Nanoseconds => DUCKDB_TYPE::DUCKDB_TYPE_TIME_NS,
+            _ => vortex_bail!("Invalid TimeUnit {} for time", unit),
+        },
+    };
+
+    Ok(LogicalType::new(duckdb_type))
+}
+
 impl TryFrom<StructFields> for LogicalType {
     type Error = VortexError;
 
@@ -324,6 +348,7 @@ mod tests {
     use std::sync::Arc;
 
     use rstest::rstest;
+    use vortex::array::EmptyMetadata;
     use vortex::dtype::DType;
     use vortex::dtype::FieldName;
     use vortex::dtype::FieldNames;
@@ -334,12 +359,14 @@ mod tests {
     use vortex::dtype::extension::ExtId;
     use vortex::dtype::extension::ExtVTable;
     use vortex::error::VortexResult;
-    use vortex::extension::EmptyMetadata;
     use vortex::extension::datetime::Date;
     use vortex::extension::datetime::Time;
     use vortex::extension::datetime::Timestamp;
     use vortex::scalar::ScalarValue;
+    use vortex_geo::extension::GeoMetadata;
+    use vortex_geo::extension::WellKnownBinary;
 
+    use crate::convert::dtype::FromLogicalType;
     use crate::cpp;
     use crate::duckdb::LogicalType;
 
@@ -562,6 +589,34 @@ mod tests {
         assert!(LogicalType::try_from(&dtype).is_err());
     }
 
+    #[test]
+    fn test_geometry_roundtrip() -> VortexResult<()> {
+        let vortex_geometry = DType::Extension(
+            ExtDType::<WellKnownBinary>::try_new(
+                GeoMetadata {
+                    crs: Some("EPSG:4326".to_string()),
+                },
+                DType::Binary(Nullability::NonNullable),
+            )?
+            .erased(),
+        );
+
+        let duckdb_geometry = LogicalType::try_from(&vortex_geometry)?;
+        assert_eq!(
+            duckdb_geometry.as_type_id(),
+            cpp::DUCKDB_TYPE::DUCKDB_TYPE_GEOMETRY
+        );
+        assert_eq!(
+            duckdb_geometry.geometry_crs().map(|crs| crs.to_string()),
+            Some("EPSG:4326".to_string())
+        );
+
+        let original = DType::from_logical_type(&duckdb_geometry, Nullability::NonNullable)?;
+        assert_eq!(original, vortex_geometry);
+
+        Ok(())
+    }
+
     #[test]
     fn test_unsupported_extension_type() {
         #[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
diff --git a/vortex-duckdb/src/convert/scalar.rs b/vortex-duckdb/src/convert/scalar.rs
index 7d0654151b3..dcd02b6a590 100644
--- a/vortex-duckdb/src/convert/scalar.rs
+++ b/vortex-duckdb/src/convert/scalar.rs
@@ -47,6 +47,7 @@ use vortex::scalar::PrimitiveScalar;
 use vortex::scalar::Scalar;
 use vortex::scalar::ScalarValue;
 use vortex::scalar::Utf8Scalar;
+use vortex_geo::extension::WellKnownBinary;
 
 use crate::convert::dtype::FromLogicalType;
 use crate::duckdb::LogicalType;
@@ -170,9 +171,22 @@ impl ToDuckDBScalar for BinaryScalar<'_> {
 }
 
 impl ToDuckDBScalar for ExtScalar<'_> {
-    /// Converts an extension scalar (primarily temporal types) to a DuckDB value.
+    /// Converts an extension scalar (temporal types or `WellKnownBinary` geometries) to a DuckDB
+    /// value.
     fn try_to_duckdb_scalar(&self) -> VortexResult<Value> {
         let logical_type = LogicalType::try_from(&DType::Extension(self.ext_dtype().clone()))?;
+
+        if let Some(wkb) = self.ext_dtype().metadata_opt::<WellKnownBinary>() {
+            let storage = self.to_storage_scalar();
+            let binary = storage
+                .as_binary_opt()
+                .ok_or_else(|| vortex_err!("WellKnownBinary storage must be a binary scalar"))?;
+            return Ok(match binary.value() {
+                Some(bytes) => Value::new_geometry(bytes.as_slice(), wkb.crs.as_deref())?,
+                None => Value::null(&logical_type),
+            });
+        }
+
         let Some(temporal) = self.ext_dtype().metadata_opt::<AnyTemporal>() else {
             vortex_bail!("Cannot convert non-temporal extension scalar to duckdb value");
         };
@@ -267,7 +281,14 @@ impl<'a> TryFrom<&'a ValueRef> for Scalar {
             ExtractedValue::Float(v) => Ok(Scalar::primitive(v, Nullable)),
             ExtractedValue::Double(v) => Ok(Scalar::primitive(v, Nullable)),
             ExtractedValue::Varchar(s) => Ok(Scalar::utf8(s, Nullable)),
-            ExtractedValue::Blob(b) => Ok(Scalar::binary(b, Nullable)),
+            ExtractedValue::Blob(b) => match &dtype {
+                DType::Binary(_) => Ok(Scalar::binary(b, Nullable)),
+                DType::Extension(ext) if ext.is::<WellKnownBinary>() => Ok(Scalar::extension_ref(
+                    ext.clone(),
+                    Scalar::binary(b, Nullable),
+                )),
+                _ => vortex_bail!("Cannot convert DuckDB blob to Vortex scalar of dtype {dtype}"),
+            },
             ExtractedValue::Date(days) => Ok(Scalar::extension::<Date>(
                 TimeUnit::Days,
                 Scalar::try_new(
@@ -351,11 +372,19 @@ impl<'a> TryFrom<&'a ValueRef> for Scalar {
 
 #[cfg(test)]
 mod tests {
+    use rstest::rstest;
+    use vortex::dtype::DType;
+    use vortex::dtype::Nullability;
+    use vortex::dtype::extension::ExtDType;
     use vortex::extension::datetime::Timestamp;
     use vortex::extension::datetime::TimestampOptions;
     use vortex::scalar::Scalar;
+    use vortex_geo::extension::GeoMetadata;
+    use vortex_geo::extension::WellKnownBinary;
 
     use crate::convert::ToDuckDBScalar;
+    use crate::cpp::DUCKDB_TYPE;
+    use crate::duckdb::Value;
 
     #[test]
     fn test_scalar_round_trip() {
@@ -414,4 +443,83 @@ mod tests {
             assert_eq!(original_scalar, roundtrip_scalar);
         }
     }
+
+    /// Sample WKB bytes for `POINT(1 2)` little-endian.
+    fn sample_wkb() -> Vec<u8> {
+        vec![
+            0x01, // little-endian
+            0x01, 0x00, 0x00, 0x00, // type = 1 (Point)
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f, // x = 1.0
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, // y = 2.0
+        ]
+    }
+
+    fn wkb_scalar(crs: Option<&str>, bytes: &[u8]) -> Scalar {
+        Scalar::extension::<WellKnownBinary>(
+            GeoMetadata {
+                crs: crs.map(str::to_string),
+            },
+            Scalar::binary(bytes.to_vec(), Nullability::Nullable),
+        )
+    }
+
+    #[rstest]
+    #[case::with_crs(Some("EPSG:4326"))]
+    #[case::no_crs(None)]
+    #[case::empty_crs(Some(""))]
+    fn test_geometry_value_extract_round_trip(#[case] crs: Option<&str>) {
+        let bytes = sample_wkb();
+        let value = Value::new_geometry(&bytes, crs).unwrap();
+
+        // The constructed value must be a GEOMETRY logical type.
+        assert_eq!(
+            value.logical_type().as_type_id(),
+            DUCKDB_TYPE::DUCKDB_TYPE_GEOMETRY
+        );
+
+        // Extract back: bytes round-trip exactly.
+        let scalar: Scalar = (&*value).try_into().unwrap();
+        let ext = scalar.as_extension();
+        let storage = ext.to_storage_scalar();
+        let storage_binary = storage.as_binary();
+        assert_eq!(storage_binary.value().unwrap().as_slice(), bytes.as_slice());
+
+        // The extension dtype should be `WellKnownBinary` and CRS should round-trip,
+        // with the documented quirk that `Some("")` collapses to `None` through DuckDB.
+        let metadata = ext.ext_dtype().metadata::<WellKnownBinary>();
+        match crs {
+            Some("") | None => assert_eq!(metadata.crs, None),
+            Some(s) => assert_eq!(metadata.crs.as_deref(), Some(s)),
+        }
+    }
+
+    #[test]
+    fn test_geometry_to_duckdb_scalar_round_trip() {
+        let bytes = sample_wkb();
+        let original = wkb_scalar(Some("EPSG:4326"), &bytes);
+
+        let duckdb_value = original.try_to_duckdb_scalar().unwrap();
+        let roundtrip: Scalar = duckdb_value.try_into().unwrap();
+
+        assert_eq!(original, roundtrip);
+    }
+
+    #[test]
+    fn test_null_geometry_to_duckdb_scalar() {
+        let dtype = ExtDType::<WellKnownBinary>::try_new(
+            GeoMetadata {
+                crs: Some("EPSG:4326".to_string()),
+            },
+            DType::Binary(Nullability::Nullable),
+        )
+        .unwrap()
+        .erased();
+        let original = Scalar::null(DType::Extension(dtype));
+
+        let duckdb_value = original.try_to_duckdb_scalar().unwrap();
+        let roundtrip: Scalar = duckdb_value.try_into().unwrap();
+
+        assert!(roundtrip.is_null());
+        assert_eq!(roundtrip.dtype(), original.dtype());
+    }
 }
diff --git a/vortex-duckdb/src/convert/vector.rs b/vortex-duckdb/src/convert/vector.rs
index a9a58c752c4..03bd45c0074 100644
--- a/vortex-duckdb/src/convert/vector.rs
+++ b/vortex-duckdb/src/convert/vector.rs
@@ -8,6 +8,7 @@ use vortex::array::ArrayRef;
 use vortex::array::IntoArray;
 use vortex::array::arrays::BoolArray;
 use vortex::array::arrays::DecimalArray;
+use vortex::array::arrays::ExtensionArray;
 use vortex::array::arrays::FixedSizeListArray;
 use vortex::array::arrays::ListViewArray;
 use vortex::array::arrays::PrimitiveArray;
@@ -15,6 +16,7 @@ use vortex::array::arrays::StructArray;
 use vortex::array::arrays::TemporalArray;
 use vortex::array::builders::ArrayBuilder;
 use vortex::array::builders::VarBinViewBuilder;
+use vortex::array::dtype::extension::ExtDType;
 use vortex::array::validity::Validity;
 use vortex::buffer::BitBuffer;
 use vortex::buffer::Buffer;
@@ -30,6 +32,8 @@ use vortex::error::VortexResult;
 use vortex::error::vortex_bail;
 use vortex::extension::datetime::TimeUnit;
 use vortex::mask::Mask;
+use vortex_geo::extension::GeoMetadata;
+use vortex_geo::extension::WellKnownBinary;
 
 use crate::cpp::DUCKDB_TYPE;
 use crate::cpp::duckdb_date;
@@ -208,8 +212,8 @@ fn process_duckdb_lists(
 
 /// Converts flat vector to a vortex array
 pub fn flat_vector_to_vortex(vector: &VectorRef, len: usize) -> VortexResult<ArrayRef> {
-    let type_id = vector.logical_type().as_type_id();
-    match type_id {
+    let logical_type = vector.logical_type();
+    match logical_type.as_type_id() {
         DUCKDB_TYPE::DUCKDB_TYPE_TIMESTAMP => {
             let arr = vector_mapped(vector, len, |duckdb_timestamp { micros }| *micros);
             Ok(TemporalArray::new_timestamp(arr, TimeUnit::Microseconds, None).into_array())
@@ -255,6 +259,18 @@ pub fn flat_vector_to_vortex(vector: &VectorRef, len: usize) -> VortexResult<Arr
             len,
             DType::Binary(Nullability::Nullable),
         )),
+        DUCKDB_TYPE::DUCKDB_TYPE_GEOMETRY => {
+            let wkb_values =
+                vector_as_string_blob(vector, len, DType::Binary(Nullability::Nullable));
+            let crs = logical_type.geometry_crs().map(|crs| crs.to_string());
+            let wkb_type = ExtDType::<WellKnownBinary>::try_new(
+                GeoMetadata { crs },
+                DType::Binary(Nullability::Nullable),
+            )?
+            .erased();
+
+            Ok(ExtensionArray::try_new(wkb_type, wkb_values.into_array())?.into_array())
+        }
         DUCKDB_TYPE::DUCKDB_TYPE_BOOLEAN => {
             let data = vector.as_slice_with_len::<bool>(len);
 
@@ -345,7 +361,7 @@ pub fn flat_vector_to_vortex(vector: &VectorRef, len: usize) -> VortexResult<Arr
             StructArray::try_new(names, children, len, vector.validity_ref(len).to_validity())
                 .map(|a| a.into_array())
         }
-        _ => unimplemented!("missing impl for {type_id:?}"),
+        type_id => unimplemented!("missing impl for {type_id:?}"),
     }
 }
 
@@ -375,17 +391,24 @@ pub fn data_chunk_to_vortex(
 mod tests {
     use std::ffi::CString;
 
+    use geo_types::point;
     use vortex::array::LEGACY_SESSION;
     use vortex::array::VortexSessionExecute;
     use vortex::array::arrays::BoolArray;
+    use vortex::array::arrays::Extension;
+    use vortex::array::arrays::VarBinViewArray;
     use vortex::array::arrays::fixed_size_list::FixedSizeListArrayExt;
     use vortex::array::arrays::listview::ListViewArrayExt;
     use vortex::array::arrays::struct_::StructArrayExt;
     use vortex::array::assert_arrays_eq;
     use vortex::error::VortexExpect;
     use vortex::mask::Mask;
+    use vortex_geo::extension::WellKnownBinaryData;
+    use wkb::writer::WriteOptions;
+    use wkb::writer::write_point;
 
     use super::*;
+    use crate::cpp;
     use crate::cpp::DUCKDB_TYPE;
     use crate::duckdb::LogicalType;
     use crate::duckdb::Vector;
@@ -963,4 +986,70 @@ mod tests {
             Mask::from_indices(3, vec![0, 2])
         );
     }
+
+    #[test]
+    fn test_geometry_vector_conversion() -> VortexResult<()> {
+        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+
+        let mut wkb_a: Vec<u8> = Vec::new();
+        write_point(
+            &mut wkb_a,
+            &point!(x: 1.0_f64, y: 2.0_f64),
+            &WriteOptions::default(),
+        )
+        .map_err(|e| vortex::error::vortex_err!("writing WKB point: {e}"))?;
+        let mut wkb_b: Vec<u8> = Vec::new();
+        write_point(
+            &mut wkb_b,
+            &point!(x: 3.5_f64, y: -4.25_f64),
+            &WriteOptions::default(),
+        )
+        .map_err(|e| vortex::error::vortex_err!("writing WKB point: {e}"))?;
+
+        let len = 3;
+        let logical_type = LogicalType::geometry_type(Some("EPSG:4326"))?;
+        let mut vector = Vector::with_capacity(&logical_type, len);
+
+        // WKB contains embedded null bytes, so use the length-aware assignment.
+        unsafe {
+            cpp::duckdb_vector_assign_string_element_len(
+                vector.as_ptr(),
+                0,
+                wkb_a.as_ptr().cast(),
+                wkb_a.len() as _,
+            );
+            cpp::duckdb_vector_assign_string_element_len(
+                vector.as_ptr(),
+                2,
+                wkb_b.as_ptr().cast(),
+                wkb_b.len() as _,
+            );
+        }
+
+        // SAFETY: Vector was created with this length.
+        let validity_slice = unsafe { vector.ensure_validity_bitslice(len) };
+        validity_slice.set(1, false);
+
+        let result = flat_vector_to_vortex(&vector, len)?;
+        let extension = result
+            .as_opt::<Extension>()
+            .vortex_expect("expected ExtensionArray")
+            .into_owned();
+        let wkb_data = WellKnownBinaryData::try_from(extension)?;
+
+        assert_eq!(wkb_data.geo_metadata().crs.as_deref(), Some("EPSG:4326"));
+
+        let storage = wkb_data
+            .wkb_values()
+            .clone()
+            .execute::<VarBinViewArray>(&mut ctx)?;
+        let expected = VarBinViewArray::from_iter_nullable_bin([
+            Some(wkb_a.as_slice()),
+            None,
+            Some(wkb_b.as_slice()),
+        ]);
+        assert_arrays_eq!(storage, expected);
+
+        Ok(())
+    }
 }
diff --git a/vortex-duckdb/src/duckdb/logical_type.rs b/vortex-duckdb/src/duckdb/logical_type.rs
index 83bea019e32..baee97d5b87 100644
--- a/vortex-duckdb/src/duckdb/logical_type.rs
+++ b/vortex-duckdb/src/duckdb/logical_type.rs
@@ -174,6 +174,20 @@ impl LogicalType {
     pub fn date() -> Self {
         Self::new(DUCKDB_TYPE::DUCKDB_TYPE_DATE)
     }
+
+    /// Creates a DuckDB GEOMETRY logical type with the given CRS (Coordinate Reference System).
+    ///
+    /// Pass `None` for a GEOMETRY with no associated CRS.
+    pub fn geometry_type(crs: Option<&str>) -> VortexResult<Self> {
+        let Ok(crs) = CString::new(crs.unwrap_or("")) else {
+            vortex_bail!("CRS must not contain NUL bytes");
+        };
+        let ptr = unsafe { duckdb_vx_create_geometry(crs.as_ptr()) };
+        if ptr.is_null() {
+            vortex_bail!("Failed to create GEOMETRY logical type");
+        }
+        Ok(unsafe { Self::own(ptr) })
+    }
 }
 
 impl LogicalTypeRef {
@@ -194,6 +208,17 @@ impl LogicalTypeRef {
         matches!(self.as_type_id(), DUCKDB_TYPE::DUCKDB_TYPE_DECIMAL)
     }
 
+    pub fn geometry_crs(&self) -> Option<DDBString> {
+        unsafe {
+            let c_string = duckdb_geometry_type_get_crs(self.as_ptr());
+            if c_string.is_null() {
+                None
+            } else {
+                Some(DDBString::own(c_string))
+            }
+        }
+    }
+
     pub fn array_child_type(&self) -> LogicalType {
         unsafe { LogicalType::own(duckdb_array_type_child_type(self.as_ptr())) }
     }
@@ -528,6 +553,16 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_create_geometry_type() -> VortexResult<()> {
+        let no_crs = LogicalType::geometry_type(None)?;
+        assert_eq!(no_crs.as_type_id(), DUCKDB_TYPE::DUCKDB_TYPE_GEOMETRY);
+
+        let with_crs = LogicalType::geometry_type(Some("EPSG:4326"))?;
+        assert_eq!(with_crs.as_type_id(), DUCKDB_TYPE::DUCKDB_TYPE_GEOMETRY);
+        Ok(())
+    }
+
     #[test]
     fn test_clone_union_logical_type() {
         let str_type = LogicalType::new(DUCKDB_TYPE::DUCKDB_TYPE_VARCHAR);
diff --git a/vortex-duckdb/src/duckdb/value.rs b/vortex-duckdb/src/duckdb/value.rs
index 752f1ccca70..fa849932967 100644
--- a/vortex-duckdb/src/duckdb/value.rs
+++ b/vortex-duckdb/src/duckdb/value.rs
@@ -2,9 +2,11 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::ffi::CStr;
+use std::ffi::CString;
 use std::fmt::Debug;
 use std::fmt::Display;
 use std::fmt::Formatter;
+use std::ptr;
 
 use num_traits::AsPrimitive;
 use vortex::buffer::BufferString;
@@ -12,6 +14,7 @@ use vortex::buffer::ByteBuffer;
 use vortex::dtype::NativeDType;
 use vortex::error::VortexError;
 use vortex::error::VortexExpect;
+use vortex::error::VortexResult;
 use vortex::error::vortex_err;
 use vortex::error::vortex_panic;
 
@@ -97,12 +100,15 @@ impl ValueRef {
                 ExtractedValue::Varchar(string)
             }
             DUCKDB_TYPE::DUCKDB_TYPE_BLOB => {
-                let blob = unsafe { cpp::duckdb_get_blob(self.as_ptr()) };
-                let slice =
-                    unsafe { std::slice::from_raw_parts(blob.data.cast::<u8>(), blob.size.as_()) };
-                let bytes = ByteBuffer::copy_from(slice);
-                unsafe { cpp::duckdb_free(blob.data) };
-                ExtractedValue::Blob(bytes)
+                ExtractedValue::Blob(unsafe { take_blob(cpp::duckdb_get_blob(self.as_ptr())) })
+            }
+            DUCKDB_TYPE::DUCKDB_TYPE_GEOMETRY => {
+                // GEOMETRY values are WKB blobs in DuckDB; we read the bytes directly via a shim
+                // that bypasses the GEOMETRY -> BLOB default cast (which requires spatial loaded).
+                // CRS lives on the logical type and is not part of the extracted bytes.
+                ExtractedValue::Blob(unsafe {
+                    take_blob(cpp::duckdb_vx_value_get_geometry(self.as_ptr()))
+                })
             }
             DUCKDB_TYPE::DUCKDB_TYPE_DATE => {
                 ExtractedValue::Date(unsafe { cpp::duckdb_get_date(self.as_ptr()).days })
@@ -250,6 +256,24 @@ impl Value {
     pub fn new_date(days: i32) -> Self {
         unsafe { Self::own(cpp::duckdb_create_date(cpp::duckdb_date { days })) }
     }
+
+    /// Creates a DuckDB GEOMETRY value from WKB bytes and an optional CRS.
+    ///
+    /// Pass `None` (or an empty string) for `crs` to create a geometry value with no CRS.
+    pub fn new_geometry(wkb: &[u8], crs: Option<&str>) -> VortexResult<Self> {
+        let crs_c = crs
+            .map(CString::new)
+            .transpose()
+            .map_err(|_| vortex_err!("CRS must not contain NUL bytes"))?;
+        let crs_ptr = crs_c.as_ref().map_or(ptr::null(), |c| c.as_ptr());
+        Ok(unsafe {
+            Self::own(cpp::duckdb_vx_value_create_geometry(
+                wkb.as_ptr(),
+                wkb.len() as idx_t,
+                crs_ptr,
+            ))
+        })
+    }
 }
 
 impl Display for ValueRef {
@@ -267,6 +291,28 @@ impl Display for Value {
     }
 }
 
+/// Copies the bytes of a `duckdb_blob` into a `ByteBuffer` and frees the underlying allocation.
+///
+/// # Safety
+///
+/// `blob` must be a freshly returned value from a DuckDB allocator (`duckdb_malloc` or one of the
+/// `duckdb_get_*` accessors that allocate).
+unsafe fn take_blob(blob: cpp::duckdb_blob) -> ByteBuffer {
+    let size: usize = blob.size.as_();
+    // `slice::from_raw_parts` requires a non-null, aligned pointer even for zero-length slices,
+    // and `duckdb_malloc(0)` is permitted to return null. Skip the slice construction in that case.
+    let bytes = if size == 0 {
+        ByteBuffer::empty()
+    } else {
+        let slice = unsafe { std::slice::from_raw_parts(blob.data.cast::<u8>(), size) };
+        ByteBuffer::copy_from(slice)
+    };
+    if !blob.data.is_null() {
+        unsafe { cpp::duckdb_free(blob.data) };
+    }
+    bytes
+}
+
 #[inline]
 pub fn i128_from_parts(high: i64, low: u64) -> i128 {
     ((high as i128) << 64) | (low as i128)
diff --git a/vortex-duckdb/src/duckdb/vector.rs b/vortex-duckdb/src/duckdb/vector.rs
index 9a160f1668e..3f0330657ae 100644
--- a/vortex-duckdb/src/duckdb/vector.rs
+++ b/vortex-duckdb/src/duckdb/vector.rs
@@ -160,18 +160,18 @@ impl VectorRef {
         !is_valid
     }
 
-    pub unsafe fn set_vector_buffer(&self, buffer: &VectorBufferRef) {
+    pub unsafe fn set_vector_buffer(&mut self, buffer: &VectorBufferRef) {
         unsafe { cpp::duckdb_vx_vector_set_vector_data_buffer(self.as_ptr(), buffer.as_ptr()) }
     }
 
-    pub fn add_string_vector_buffer(&self, buffer: &VectorBufferRef) {
+    pub fn add_string_vector_buffer(&mut self, buffer: &VectorBufferRef) {
         unsafe {
             cpp::duckdb_vx_string_vector_add_vector_data_buffer(self.as_ptr(), buffer.as_ptr())
         }
     }
 
     /// Sets the data pointer for the vector. This is the start of the values array in the vector.
-    pub unsafe fn set_data_ptr<T>(&self, ptr: *mut T) {
+    pub unsafe fn set_data_ptr<T>(&mut self, ptr: *mut T) {
         unsafe { cpp::duckdb_vx_vector_set_data_ptr(self.as_ptr(), ptr as *mut c_void) }
     }
 
@@ -184,7 +184,7 @@ impl VectorRef {
     /// The data pointer must point to a valid `u64` array with at least
     /// `u64_offset + capacity.div_ceil(64)` elements.
     pub(crate) unsafe fn set_validity_data(
-        &self,
+        &mut self,
         u64_offset: usize,
         capacity: usize,
         zero_copy: &ValidityData,
@@ -455,7 +455,11 @@ mod tests {
 
         let validity = vector.validity_ref(len);
         let validity = validity.to_validity();
-        assert!(validity.is_null(0).unwrap());
+        assert!(
+            validity
+                .execute_is_null(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .unwrap()
+        );
     }
 
     #[test]
@@ -468,7 +472,11 @@ mod tests {
 
         let validity = vector.validity_ref(len);
         let validity = validity.to_validity();
-        assert!(validity.is_valid(0).unwrap());
+        assert!(
+            validity
+                .execute_is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .unwrap()
+        );
     }
 
     #[test]
diff --git a/vortex-duckdb/src/e2e_test/vortex_scan_test.rs b/vortex-duckdb/src/e2e_test/vortex_scan_test.rs
index 3e756234093..e0705e07de0 100644
--- a/vortex-duckdb/src/e2e_test/vortex_scan_test.rs
+++ b/vortex-duckdb/src/e2e_test/vortex_scan_test.rs
@@ -11,6 +11,8 @@ use std::slice;
 use std::str::FromStr;
 
 use anyhow::Result;
+use geo_types::LineString;
+use geo_types::Polygon;
 use jiff::Span;
 use jiff::Timestamp;
 use jiff::Zoned;
@@ -38,8 +40,15 @@ use vortex::file::WriteOptionsSessionExt;
 use vortex::io::runtime::BlockingRuntime;
 use vortex::scalar::PValue;
 use vortex::scalar::Scalar;
+use vortex_array::arrays::ExtensionArray;
+use vortex_array::arrays::varbin::builder::VarBinBuilder;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::extension::ExtDType;
+use vortex_geo::extension::GeoMetadata;
+use vortex_geo::extension::WellKnownBinary;
 use vortex_runend::RunEnd;
 use vortex_sequence::Sequence;
+use wkb::writer::WriteOptions;
 
 use crate::RUNTIME;
 use crate::SESSION;
@@ -995,3 +1004,47 @@ fn test_vortex_encodings_roundtrip() {
     let fixed_child_values = fixed_child.as_slice_with_len::<i32>(10); // 10 total child elements
     assert_eq!(fixed_child_values, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 }
+
+#[test]
+fn test_geometry() {
+    let file = RUNTIME.block_on(async {
+        let rect10 = Polygon::new(
+            LineString::from_iter([[0., 0.], [10., 0.], [10., 10.], [0., 10.], [0., 0.]]),
+            vec![],
+        );
+        let mut wkb_binary: Vec<u8> = Vec::new();
+        wkb::writer::write_polygon(&mut wkb_binary, &rect10, &WriteOptions::default())
+            .expect("serializing WKB");
+        let mut geometry = VarBinBuilder::<u32>::with_capacity(10);
+        for _ in 0..10 {
+            geometry.append_value(wkb_binary.as_slice());
+        }
+        let geometry = geometry.finish(DType::Binary(Nullability::NonNullable));
+
+        let geometry = ExtensionArray::new(
+            ExtDType::<WellKnownBinary>::try_new(
+                GeoMetadata {
+                    crs: Some("EPSG:32600".to_string()),
+                },
+                geometry.dtype().clone(),
+            )
+            .expect("making extension array")
+            .erased(),
+            geometry.into_array(),
+        )
+        .into_array();
+
+        write_single_column_vortex_file("geometry", geometry).await
+    });
+
+    let conn = database_connection();
+    conn.query("INSTALL spatial; LOAD spatial;").unwrap();
+    let file_path = file.path().to_string_lossy();
+    let result = conn
+        .query(&format!("SELECT SUM(ST_Area(geometry)) FROM '{file_path}'"))
+        .unwrap();
+    let chunk = result.into_iter().next().unwrap();
+    let vec = chunk.get_vector(0);
+    let area = vec.as_slice_with_len::<f64>(chunk.len().as_())[0];
+    assert_eq!(area, 1000.0);
+}
diff --git a/vortex-duckdb/src/exporter/canonical.rs b/vortex-duckdb/src/exporter/canonical.rs
index a46b22df6f9..7ee47a40642 100644
--- a/vortex-duckdb/src/exporter/canonical.rs
+++ b/vortex-duckdb/src/exporter/canonical.rs
@@ -3,7 +3,6 @@
 use vortex::array::ArrayRef;
 use vortex::array::Canonical;
 use vortex::array::ExecutionCtx;
-use vortex::array::arrays::TemporalArray;
 use vortex::error::VortexResult;
 use vortex::error::vortex_bail;
 
@@ -12,11 +11,11 @@ use crate::exporter::ConversionCache;
 use crate::exporter::all_invalid;
 use crate::exporter::bool;
 use crate::exporter::decimal;
+use crate::exporter::extension;
 use crate::exporter::fixed_size_list;
 use crate::exporter::list_view;
 use crate::exporter::primitive;
 use crate::exporter::struct_;
-use crate::exporter::temporal;
 use crate::exporter::varbinview;
 
 pub(crate) fn new_exporter(
@@ -33,12 +32,7 @@ pub(crate) fn new_exporter(
         Canonical::List(array) => list_view::new_exporter(array, cache, ctx),
         Canonical::FixedSizeList(array) => fixed_size_list::new_exporter(array, cache, ctx),
         Canonical::Struct(array) => struct_::new_exporter(array, cache, ctx),
-        Canonical::Extension(ext) => {
-            if let Ok(temporal_array) = TemporalArray::try_from(ext) {
-                return temporal::new_exporter(temporal_array, ctx);
-            }
-            vortex_bail!("no non-temporal extension exporter")
-        }
+        Canonical::Extension(ext) => extension::new_exporter(ext, ctx),
         Canonical::Variant(_) => {
             vortex_bail!("Variant arrays can't be exported to DuckDB")
         }
diff --git a/vortex-duckdb/src/exporter/extension.rs b/vortex-duckdb/src/exporter/extension.rs
new file mode 100644
index 00000000000..221dc92a85f
--- /dev/null
+++ b/vortex-duckdb/src/exporter/extension.rs
@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ExecutionCtx;
+use vortex::array::arrays::ExtensionArray;
+use vortex::array::arrays::TemporalArray;
+use vortex::array::arrays::extension::ExtensionArrayExt;
+use vortex::array::extension::datetime::AnyTemporal;
+use vortex::error::VortexResult;
+use vortex::error::vortex_bail;
+use vortex_geo::extension::WellKnownBinary;
+use vortex_geo::extension::WellKnownBinaryData;
+
+use crate::exporter::ColumnExporter;
+use crate::exporter::geo;
+use crate::exporter::temporal;
+
+pub(crate) fn new_exporter(
+    ext: ExtensionArray,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<Box<dyn ColumnExporter>> {
+    if ext.ext_dtype().is::<AnyTemporal>() {
+        return temporal::new_exporter(TemporalArray::try_from(ext)?, ctx);
+    }
+
+    if ext.ext_dtype().is::<WellKnownBinary>() {
+        return geo::new_wkb_exporter(WellKnownBinaryData::try_from(ext)?, ctx);
+    }
+
+    vortex_bail!("no non-temporal extension exporter")
+}
diff --git a/vortex-duckdb/src/exporter/fixed_size_list.rs b/vortex-duckdb/src/exporter/fixed_size_list.rs
index ed93ad2b9c1..11b6e29a605 100644
--- a/vortex-duckdb/src/exporter/fixed_size_list.rs
+++ b/vortex-duckdb/src/exporter/fixed_size_list.rs
@@ -7,7 +7,7 @@
 //! The ARRAY type in DuckDB corresponds to Vortex's [`DType::FixedSizeList`], where all
 //! lists have the same number of elements.
 //!
-//! [`DType::FixedSizeList`]: vortex_array::dtype::DType::FixedSizeList
+//! [`DType::FixedSizeList`]: vortex::dtype::DType::FixedSizeList
 use vortex::array::ExecutionCtx;
 use vortex::array::arrays::FixedSizeListArray;
 use vortex::array::arrays::fixed_size_list::FixedSizeListArrayExt;
diff --git a/vortex-duckdb/src/exporter/geo.rs b/vortex-duckdb/src/exporter/geo.rs
new file mode 100644
index 00000000000..1287ed019e2
--- /dev/null
+++ b/vortex-duckdb/src/exporter/geo.rs
@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ExecutionCtx;
+use vortex::array::arrays::VarBinViewArray;
+use vortex::error::VortexResult;
+use vortex_geo::extension::WellKnownBinaryData;
+
+use crate::exporter::ColumnExporter;
+use crate::exporter::varbinview::new_exporter;
+
+/// Create a new exporter for geospatial data stored as Well-Known Binary (WKB) format.
+pub(crate) fn new_wkb_exporter(
+    array: WellKnownBinaryData,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<Box<dyn ColumnExporter>> {
+    let values = array.wkb_values().clone().execute::<VarBinViewArray>(ctx)?;
+    new_exporter(values, ctx)
+}
diff --git a/vortex-duckdb/src/exporter/list_view.rs b/vortex-duckdb/src/exporter/list_view.rs
index a0ee1614001..a4cb61895f3 100644
--- a/vortex-duckdb/src/exporter/list_view.rs
+++ b/vortex-duckdb/src/exporter/list_view.rs
@@ -75,7 +75,7 @@ pub(crate) fn new_exporter(
         }
     } else if array.upper_bound_density(ctx)? < DEFAULT_REBUILD_DENSITY_THRESHOLD {
         // Overlaps, gaps, or garbage may be present, so a full rebuild is needed to reclaim waste.
-        array.rebuild(ListViewRebuildMode::MakeZeroCopyToList)?
+        array.rebuild(ListViewRebuildMode::MakeZeroCopyToList, ctx)?
     } else {
         array
     };
diff --git a/vortex-duckdb/src/exporter/mod.rs b/vortex-duckdb/src/exporter/mod.rs
index a438adc59d8..1e470aae3fc 100644
--- a/vortex-duckdb/src/exporter/mod.rs
+++ b/vortex-duckdb/src/exporter/mod.rs
@@ -8,7 +8,9 @@ mod canonical;
 mod constant;
 mod decimal;
 mod dict;
+mod extension;
 mod fixed_size_list;
+mod geo;
 mod list;
 mod list_view;
 mod primitive;
diff --git a/vortex-duckdb/src/exporter/struct_.rs b/vortex-duckdb/src/exporter/struct_.rs
index f18c5495754..76c07d672a3 100644
--- a/vortex-duckdb/src/exporter/struct_.rs
+++ b/vortex-duckdb/src/exporter/struct_.rs
@@ -43,7 +43,7 @@ pub(crate) fn new_exporter(
     let children = fields
         .iter()
         .map(|child| {
-            if validity.to_bit_buffer().true_count() != validity.len() {
+            if validity.bit_buffer_view().true_count() != validity.len() {
                 // TODO(joe): use new mask.
                 new_array_exporter(
                     child.clone().mask(validity.clone().into_array())?,
diff --git a/vortex-duckdb/src/exporter/validity.rs b/vortex-duckdb/src/exporter/validity.rs
index d1fbf8123cb..429699e9f55 100644
--- a/vortex-duckdb/src/exporter/validity.rs
+++ b/vortex-duckdb/src/exporter/validity.rs
@@ -10,6 +10,8 @@ use crate::duckdb::VectorBuffer;
 use crate::duckdb::VectorRef;
 use crate::exporter::ColumnExporter;
 
+/// A [`ColumnExporter`] that wraps another exporter with a validity
+/// export, allowing you to write data using something else here.
 struct ValidityExporter {
     mask: Mask,
     /// If the mask's bit buffer is u64-aligned with no sub-byte offset,
diff --git a/vortex-duckdb/src/filesystem.rs b/vortex-duckdb/src/filesystem.rs
index b88ce80fd38..b9c09dfe9d3 100644
--- a/vortex-duckdb/src/filesystem.rs
+++ b/vortex-duckdb/src/filesystem.rs
@@ -147,6 +147,22 @@ impl FileSystem for DuckDbFileSystem {
         .boxed()
     }
 
+    async fn head(&self, path: &str) -> VortexResult<Option<FileListing>> {
+        // DuckDB's filesystem exposes no stat/exists call, so probe the path by opening it and
+        // reading its size. DuckDB does not distinguish "not found" from other open failures, so
+        // any open error is treated as a missing file (logged for diagnosability).
+        match self.open_read(path).await {
+            Ok(reader) => Ok(Some(FileListing {
+                path: path.to_string(),
+                size: Some(reader.size().await?),
+            })),
+            Err(e) => {
+                tracing::debug!("head({path}): treating open error as not-found: {e}");
+                Ok(None)
+            }
+        }
+    }
+
     async fn open_read(&self, path: &str) -> VortexResult<Arc<dyn VortexReadAt>> {
         let mut url = self.base_url.clone();
         url.set_path(path);
diff --git a/vortex-duckdb/src/lib.rs b/vortex-duckdb/src/lib.rs
index 5208deca4fc..8a1b6884401 100644
--- a/vortex-duckdb/src/lib.rs
+++ b/vortex-duckdb/src/lib.rs
@@ -32,6 +32,7 @@ mod projection;
 mod table_function;
 
 #[rustfmt::skip]
+#[allow(rustdoc::all)]
 #[path = "./cpp.rs"]
 /// This module provides the FFI interface to our C++ code exposing additional functionality
 /// for DuckDB, such as custom data types and functions.
@@ -43,8 +44,11 @@ mod e2e_test;
 
 // A global runtime for Vortex operations within DuckDB.
 static RUNTIME: LazyLock<CurrentThreadRuntime> = LazyLock::new(CurrentThreadRuntime::new);
-static SESSION: LazyLock<VortexSession> =
-    LazyLock::new(|| VortexSession::default().with_handle(RUNTIME.handle()));
+static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
+    let session = VortexSession::default().with_handle(RUNTIME.handle());
+    vortex_geo::initialize(&session);
+    session
+});
 
 // Duckdb's logger requires a *Context as first argument which
 // would be hard to integrate with tracing::. We use logging for
diff --git a/vortex-ffi/Cargo.toml b/vortex-ffi/Cargo.toml
index 83a0737e2bd..6407f97fe46 100644
--- a/vortex-ffi/Cargo.toml
+++ b/vortex-ffi/Cargo.toml
@@ -47,7 +47,7 @@ mimalloc = ["dep:mimalloc"]
 
 [lib]
 name = "vortex_ffi"
-crate-type = ["staticlib", "cdylib"]
+crate-type = ["rlib", "staticlib", "cdylib"]
 
 [lints]
 workspace = true
diff --git a/vortex-ffi/build.rs b/vortex-ffi/build.rs
index 16e72db792a..932c438e533 100644
--- a/vortex-ffi/build.rs
+++ b/vortex-ffi/build.rs
@@ -17,21 +17,20 @@ fn main() {
         println!("cargo:rerun-if-env-changed={env}");
     }
 
-    let is_asan = env::var("CARGO_ENCODED_RUSTFLAGS")
-        .unwrap_or_default()
-        .contains("address");
-    if is_asan {
+    // Skip cbindgen under sanitizers: its nested expansion build drops the sanitizer flag and
+    // mismatches the sanitizer-built deps.
+    let rustflags = env::var("CARGO_ENCODED_RUSTFLAGS").unwrap_or_default();
+
+    if rustflags.contains("address") {
         println!("cargo:info=building with asan");
         println!("cargo:rustc-cfg=vortex_asan");
         println!("cargo:info=Skipping header generation due to sanitizers");
         return;
     }
 
-    if env::var("CARGO_ENCODED_RUSTFLAGS")
-        .unwrap_or_default()
-        .contains("sanitizer")
-    {
+    if rustflags.contains("sanitizer") {
         println!("cargo:info=Skipping header generation due to sanitizers");
+        return;
     }
 
     if env::var("MIRI").is_ok() || env::var("MIRIFLAGS").is_ok() {
diff --git a/vortex-ffi/cinclude/vortex.h b/vortex-ffi/cinclude/vortex.h
index eab34c0d635..26c7b409cd9 100644
--- a/vortex-ffi/cinclude/vortex.h
+++ b/vortex-ffi/cinclude/vortex.h
@@ -161,6 +161,9 @@ typedef enum {
     PTYPE_F64 = 10,
 } vx_ptype;
 
+/**
+ * Validity representation for arrays constructed through the C FFI.
+ */
 typedef enum {
     /**
      * Items can't be null
@@ -417,9 +420,6 @@ typedef struct vx_array vx_array;
  * Once the iterator is finished (returns `null` from [`vx_array_iterator_next`]), it may panic
  * on subsequent calls to [`vx_array_iterator_next`].
  *
- * Even after the iterator is finished, an owned iterator must be released by calling
- * [`vx_array_iter_free`].
- *
  * Iterators may be passed between threads, but calls to [`vx_array_iterator_next`] should be
  * serialized and not invoked concurrently.
  */
@@ -533,7 +533,13 @@ typedef struct vx_struct_fields vx_struct_fields;
  */
 typedef struct vx_struct_fields_builder vx_struct_fields_builder;
 
+/**
+ * Array validity descriptor used by C FFI constructors.
+ */
 typedef struct {
+    /**
+     * The kind of validity represented by this descriptor.
+     */
     vx_validity_type type;
     /**
      * If type is not VX_VALIDITY_ARRAY, this is NULL.
@@ -673,7 +679,7 @@ void vx_array_get_validity(const vx_array *array, vx_validity *validity, vx_erro
 size_t vx_array_len(const vx_array *array);
 
 /**
- * Get the [`crate::vx_dtype`] of the array.
+ * Get the [`struct@crate::dtype::vx_dtype`] of the array.
  *
  * The returned pointer is valid as long as the array is valid.
  * Do NOT free the returned dtype pointer - it shares the lifetime of the array.
diff --git a/vortex-ffi/src/array.rs b/vortex-ffi/src/array.rs
index f70af840385..07dbe0eeb55 100644
--- a/vortex-ffi/src/array.rs
+++ b/vortex-ffi/src/array.rs
@@ -26,6 +26,7 @@ use vortex::buffer::Buffer;
 use vortex::dtype::DType;
 use vortex::dtype::half::f16;
 use vortex::error::VortexExpect;
+use vortex::error::VortexResult;
 use vortex::error::vortex_ensure;
 use vortex::error::vortex_err;
 
@@ -59,6 +60,19 @@ arc_wrapper!(
     vx_array
 );
 
+/// Borrow the [`ArrayRef`] behind a [`vx_array`] handle, erroring on a null pointer.
+///
+/// A building block for FFI crates layered on top of the base Vortex C API.
+///
+/// # Safety
+///
+/// `array` must be null or a valid `vx_array` pointer created by this crate, and must stay valid
+/// for the returned reference.
+pub unsafe fn vx_array_ref<'a>(array: *const vx_array) -> VortexResult<&'a ArrayRef> {
+    vortex_ensure!(!array.is_null(), "null vx_array");
+    Ok(vx_array::as_ref(array))
+}
+
 /// Check if array's dtype is nullable.
 /// As a particular example, a Null array is nullable.
 #[unsafe(no_mangle)]
@@ -111,6 +125,7 @@ pub unsafe extern "C-unwind" fn vx_array_is_primitive(
     }
 }
 
+/// Validity representation for arrays constructed through the C FFI.
 #[repr(C)]
 pub enum vx_validity_type {
     /// Items can't be null
@@ -124,8 +139,10 @@ pub enum vx_validity_type {
     VX_VALIDITY_ARRAY = 3,
 }
 
+/// Array validity descriptor used by C FFI constructors.
 #[repr(C)]
 pub struct vx_validity {
+    /// The kind of validity represented by this descriptor.
     pub r#type: vx_validity_type,
     /// If type is not VX_VALIDITY_ARRAY, this is NULL.
     /// If type is VX_VALIDITY_ARRAY, this is set to an owned boolean validity
@@ -191,7 +208,7 @@ pub unsafe extern "C-unwind" fn vx_array_len(array: *const vx_array) -> usize {
     vx_array::as_ref(array).len()
 }
 
-/// Get the [`crate::vx_dtype`] of the array.
+/// Get the [`struct@crate::dtype::vx_dtype`] of the array.
 ///
 /// The returned pointer is valid as long as the array is valid.
 /// Do NOT free the returned dtype pointer - it shares the lifetime of the array.
diff --git a/vortex-ffi/src/array_iterator.rs b/vortex-ffi/src/array_iterator.rs
index 6fa5fc20b25..50b95e96d1a 100644
--- a/vortex-ffi/src/array_iterator.rs
+++ b/vortex-ffi/src/array_iterator.rs
@@ -17,9 +17,6 @@ box_dyn_wrapper!(
     /// Once the iterator is finished (returns `null` from [`vx_array_iterator_next`]), it may panic
     /// on subsequent calls to [`vx_array_iterator_next`].
     ///
-    /// Even after the iterator is finished, an owned iterator must be released by calling
-    /// [`vx_array_iter_free`].
-    ///
     /// Iterators may be passed between threads, but calls to [`vx_array_iterator_next`] should be
     /// serialized and not invoked concurrently.
     dyn ArrayIterator,
diff --git a/vortex-ffi/src/data_source.rs b/vortex-ffi/src/data_source.rs
index 80e3debcb4d..b1a25c30ddf 100644
--- a/vortex-ffi/src/data_source.rs
+++ b/vortex-ffi/src/data_source.rs
@@ -3,6 +3,7 @@
 #![allow(non_camel_case_types)]
 #![deny(missing_docs)]
 
+use std::ffi::CStr;
 use std::ffi::c_char;
 use std::ptr;
 use std::sync::Arc;
@@ -24,7 +25,6 @@ use crate::error::vx_error;
 use crate::scan::vx_estimate;
 use crate::scan::vx_estimate_type;
 use crate::session::vx_session;
-use crate::to_string;
 
 crate::arc_dyn_wrapper!(
     /// A reference to one or more (possibly remote) paths.
@@ -63,7 +63,9 @@ unsafe fn data_source_new(
     let opts = unsafe { &*opts };
     vortex_ensure!(!opts.paths.is_null());
 
-    let glob = unsafe { to_string(opts.paths) };
+    let glob = unsafe { CStr::from_ptr(opts.paths) }
+        .to_string_lossy()
+        .into_owned();
     let mut data_source = MultiFileDataSource::new(session.clone());
     for glob in glob.split(',') {
         data_source = data_source.with_glob(glob, None);
diff --git a/vortex-ffi/src/error.rs b/vortex-ffi/src/error.rs
index 4bc5a1ed4be..9459d77c6a4 100644
--- a/vortex-ffi/src/error.rs
+++ b/vortex-ffi/src/error.rs
@@ -19,13 +19,28 @@ box_wrapper!(
     vx_error
 );
 
+/// Create an owned Vortex FFI error from a message.
+pub(crate) fn vx_error_new(message: &str) -> *mut vx_error {
+    vx_error::new(VortexError {
+        message: message.into(),
+    })
+}
+
 /// Write an error message to `error` which has not been populated before.
+/// A null `error` pointer discards the message.
 pub(crate) fn write_error(error: *mut *mut vx_error, message: &str) {
-    assert!(!error.is_null());
-    let err = vx_error::new(VortexError {
-        message: message.into(),
-    });
-    unsafe { error.write(err) };
+    if error.is_null() {
+        return;
+    }
+    unsafe { error.write(vx_error_new(message)) };
+}
+
+/// Clear `*error_out` to null unless `error_out` itself is null.
+fn clear_error(error_out: *mut *mut vx_error) {
+    if error_out.is_null() {
+        return;
+    }
+    unsafe { error_out.write(ptr::null_mut()) };
 }
 
 #[inline]
@@ -35,7 +50,7 @@ pub fn try_or_default<T: Default>(
 ) -> T {
     match function() {
         Ok(value) => {
-            unsafe { error_out.write(ptr::null_mut()) };
+            clear_error(error_out);
             value
         }
         Err(err) => {
@@ -45,6 +60,10 @@ pub fn try_or_default<T: Default>(
     }
 }
 
+/// Run `function`, returning its value on success and `error_value` on failure.
+///
+/// `error_out` may be null, in which case error details are discarded. When it is non-null,
+/// `*error_out` is cleared to null on success and set to an owned `vx_error` on failure.
 pub fn try_or<T>(
     error_out: *mut *mut vx_error,
     error_value: T,
@@ -52,7 +71,7 @@ pub fn try_or<T>(
 ) -> T {
     match function() {
         Ok(value) => {
-            unsafe { error_out.write(ptr::null_mut()) };
+            clear_error(error_out);
             value
         }
         Err(err) => {
@@ -70,3 +89,41 @@ pub fn try_or<T>(
 pub unsafe extern "C-unwind" fn vx_error_get_message(error: *const vx_error) -> *const vx_string {
     vx_string::new_ref(&vx_error::as_ref(error).message)
 }
+
+#[cfg(test)]
+mod tests {
+    use std::ptr;
+
+    use vortex::error::vortex_err;
+
+    use super::*;
+    use crate::error::vx_error_free;
+
+    #[test]
+    fn test_try_or_null_error_out() {
+        // A null error_out must be tolerated on both the success and failure paths.
+        assert_eq!(try_or(ptr::null_mut(), -1, || Ok(42)), 42);
+        assert_eq!(try_or(ptr::null_mut(), -1, || Err(vortex_err!("boom"))), -1);
+    }
+
+    #[test]
+    fn test_try_or_default_null_error_out() {
+        assert_eq!(try_or_default(ptr::null_mut(), || Ok(42)), 42);
+        assert_eq!(
+            try_or_default::<i32>(ptr::null_mut(), || Err(vortex_err!("boom"))),
+            0
+        );
+    }
+
+    #[test]
+    fn test_try_or_writes_and_clears_error_out() {
+        let mut error: *mut vx_error = ptr::null_mut();
+
+        assert_eq!(try_or(&raw mut error, -1, || Err(vortex_err!("boom"))), -1);
+        assert!(!error.is_null());
+        unsafe { vx_error_free(error) };
+
+        assert_eq!(try_or(&raw mut error, -1, || Ok(42)), 42);
+        assert!(error.is_null());
+    }
+}
diff --git a/vortex-ffi/src/lib.rs b/vortex-ffi/src/lib.rs
index adc72ad1cf2..f4ce314c073 100644
--- a/vortex-ffi/src/lib.rs
+++ b/vortex-ffi/src/lib.rs
@@ -29,7 +29,16 @@ use std::ffi::c_char;
 use std::sync::Arc;
 use std::sync::LazyLock;
 
+pub use array::vx_array;
+pub use array::vx_array_ref;
+pub use error::try_or;
+pub use error::vx_error;
+pub use error::vx_error_free;
 pub use log::vx_log_level;
+pub use session::vx_session;
+pub use session::vx_session_free;
+pub use session::vx_session_new_with;
+pub use session::vx_session_ref;
 use vortex::dtype::FieldName;
 use vortex::error::VortexExpect;
 use vortex::error::VortexResult;
@@ -44,11 +53,6 @@ static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 // TODO(ngates): also create a CurrentThreadPool to manage background worker threads.
 static RUNTIME: LazyLock<CurrentThreadRuntime> = LazyLock::new(CurrentThreadRuntime::new);
 
-pub(crate) unsafe fn to_string(ptr: *const c_char) -> String {
-    let c_str = unsafe { CStr::from_ptr(ptr) };
-    c_str.to_string_lossy().into_owned()
-}
-
 /// SAFETY: name must be a non-NULL pointer
 pub(crate) unsafe fn to_field_name(name: *const c_char) -> VortexResult<FieldName> {
     let name = unsafe { CStr::from_ptr(name) }
diff --git a/vortex-ffi/src/macros.rs b/vortex-ffi/src/macros.rs
index 4b191f1c7f6..7ddf3d9d428 100644
--- a/vortex-ffi/src/macros.rs
+++ b/vortex-ffi/src/macros.rs
@@ -8,11 +8,11 @@
 //! in our APIs and reducing boilerplate code.
 //!
 //! There are four macros provided:
-//! - [`arc_wrapper!`]: Wraps a type in an `Arc<T>` for shared ownership.
-//! - [`arc_dyn_wrapper!`]: Wraps a type in an `Arc<dyn T>` for shared ownership, allowing for dynamic
+//! - `arc_wrapper!`: Wraps a type in an `Arc<T>` for shared ownership.
+//! - `arc_dyn_wrapper!`: Wraps a type in an `Arc<dyn T>` for shared ownership, allowing for dynamic
 //!   dispatch of unsized types (like trait objects).
-//! - [`box_wrapper!`]: Wraps a type in a `Box<T>` for single ownership.
-//! - [`box_dyn_wrapper!`]: Wraps a type in a `Box<dyn T>` for single ownership, allowing for dynamic
+//! - `box_wrapper!`: Wraps a type in a `Box<T>` for single ownership.
+//! - `box_dyn_wrapper!`: Wraps a type in a `Box<dyn T>` for single ownership, allowing for dynamic
 //!   dispatch of unsized types (like trait objects).
 //!
 //! Similarly to Rust, `Box` can be chosen to provide single ownership and mutability semantics,
@@ -287,6 +287,10 @@ macro_rules! box_wrapper {
             }
 
             #[doc = r" Free an owned [`" $ffi_ident "`] object."]
+            // These allows only matter once the destructor is re-exported (e.g. `vx_error_free`):
+            // its `# Safety` lives at the C boundary, and its doc links a private wrapper type.
+            #[allow(clippy::missing_safety_doc)]
+            #[allow(rustdoc::private_intra_doc_links)]
             #[unsafe(no_mangle)]
             pub unsafe extern "C-unwind" fn [<$ffi_ident _free>](ptr: *mut $ffi_ident) {
                 if ptr.is_null() {
diff --git a/vortex-ffi/src/session.rs b/vortex-ffi/src/session.rs
index 5e8fc4b4909..2af3d997444 100644
--- a/vortex-ffi/src/session.rs
+++ b/vortex-ffi/src/session.rs
@@ -2,6 +2,8 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use vortex::VortexSessionDefault;
+use vortex::error::VortexResult;
+use vortex::error::vortex_ensure;
 use vortex::io::runtime::BlockingRuntime;
 use vortex::io::session::RuntimeSessionExt;
 use vortex::session::VortexSession;
@@ -15,12 +17,21 @@ box_wrapper!(
     vx_session
 );
 
+/// Create an FFI session from a configured default session.
+pub fn vx_session_new_with(
+    configure: impl FnOnce(VortexSession) -> VortexSession,
+) -> *mut vx_session {
+    vx_session::new(configure(
+        VortexSession::default().with_handle(RUNTIME.handle()),
+    ))
+}
+
 /// Create a new Vortex session.
 ///
 /// The caller is responsible for freeing the session with [`vx_session_free`].
 #[unsafe(no_mangle)]
 pub unsafe extern "C-unwind" fn vx_session_new() -> *mut vx_session {
-    vx_session::new(VortexSession::default().with_handle(RUNTIME.handle()))
+    vx_session_new_with(|session| session)
 }
 
 /// Clone a Vortex session, returning an owned copy.
@@ -32,6 +43,19 @@ pub unsafe extern "C-unwind" fn vx_session_clone(session: *const vx_session) ->
     vx_session::new(session.clone())
 }
 
+/// Borrow the [`VortexSession`] behind a [`vx_session`] handle, erroring on a null pointer.
+///
+/// A building block for FFI crates layered on top of the base Vortex C API.
+///
+/// # Safety
+///
+/// `session` must be null or a valid `vx_session` pointer created by this crate, and must stay
+/// valid for the returned reference.
+pub unsafe fn vx_session_ref<'a>(session: *const vx_session) -> VortexResult<&'a VortexSession> {
+    vortex_ensure!(!session.is_null(), "null vx_session");
+    Ok(vx_session::as_ref(session))
+}
+
 #[cfg(test)]
 mod tests {
     use crate::session::vx_session_clone;
diff --git a/vortex-ffi/test/scan.cpp b/vortex-ffi/test/scan.cpp
index bc39fa12074..2e138a12913 100644
--- a/vortex-ffi/test/scan.cpp
+++ b/vortex-ffi/test/scan.cpp
@@ -209,7 +209,7 @@ TEST_CASE("Creating datasources", "[datasource]") {
     ds = vx_data_source_new(session, &opts, &error);
     REQUIRE(ds == nullptr);
     REQUIRE(error != nullptr);
-    REQUIRE_THAT(to_string(error), ContainsSubstring("No such file or directory"));
+    REQUIRE_THAT(to_string(error), ContainsSubstring("No files matched the glob pattern"));
     vx_error_free(error);
 
     opts.paths = "/tmp2/*.vortex";
diff --git a/vortex-file/src/file.rs b/vortex-file/src/file.rs
index cbebe0297bb..23e2114b1c3 100644
--- a/vortex-file/src/file.rs
+++ b/vortex-file/src/file.rs
@@ -8,6 +8,7 @@
 
 use std::ops::Range;
 use std::sync::Arc;
+use std::sync::OnceLock;
 
 use itertools::Itertools;
 use vortex_array::ArrayRef;
@@ -51,6 +52,29 @@ pub struct VortexFile {
     segment_source: Arc<dyn SegmentSource>,
     /// The Vortex session used to open this file.
     session: VortexSession,
+    /// None id LayoutReader caching is turned off
+    layout_reader_cache: Option<OnceLock<Arc<dyn LayoutReader>>>,
+}
+
+fn layout_reader(
+    segment_source: Arc<dyn SegmentSource>,
+    footer: &Footer,
+    session: &VortexSession,
+) -> VortexResult<Arc<dyn LayoutReader>> {
+    let root_reader = footer
+        .layout()
+        // TODO(ngates): we may want to allow the user pass in a name here?
+        .new_reader("".into(), segment_source, session, &Default::default())?;
+
+    Ok(if let Some(stats) = footer.statistics().cloned() {
+        Arc::new(FileStatsLayoutReader::new(
+            root_reader,
+            stats,
+            session.clone(),
+        ))
+    } else {
+        root_reader
+    })
 }
 
 impl VortexFile {
@@ -64,6 +88,17 @@ impl VortexFile {
             footer,
             segment_source,
             session,
+            layout_reader_cache: None,
+        }
+    }
+
+    /// Enable layout reader caching
+    pub fn with_caching(self) -> Self {
+        Self {
+            footer: self.footer,
+            segment_source: self.segment_source,
+            session: self.session,
+            layout_reader_cache: Some(OnceLock::new()),
         }
     }
 
@@ -106,23 +141,30 @@ impl VortexFile {
     ///
     /// Wraps the root layout in a [`FileStatsLayoutReader`] if file stats are available.
     pub fn layout_reader(&self) -> VortexResult<Arc<dyn LayoutReader>> {
-        let segment_source = self.segment_source();
-
-        let root_reader = self
-            .footer
-            .layout()
-            // TODO(ngates): we may want to allow the user pass in a name here?
-            .new_reader("".into(), segment_source, &self.session)?;
-
-        Ok(if let Some(stats) = self.file_stats().cloned() {
-            Arc::new(FileStatsLayoutReader::new(
-                root_reader,
-                stats,
-                self.session.clone(),
-            ))
-        } else {
-            root_reader
-        })
+        match &self.layout_reader_cache {
+            None => layout_reader(
+                Arc::clone(&self.segment_source),
+                &self.footer,
+                &self.session,
+            ),
+            Some(reader) => {
+                // get_or_try_init is unstable
+                if let Some(val) = reader.get() {
+                    Ok(Arc::clone(val))
+                } else {
+                    let inner = layout_reader(
+                        Arc::clone(&self.segment_source),
+                        &self.footer,
+                        &self.session,
+                    )?;
+                    Ok(if let Err(val) = reader.set(Arc::clone(&inner)) {
+                        val
+                    } else {
+                        inner
+                    })
+                }
+            }
+        }
     }
 
     /// Create a [`DataSource`](vortex_scan::DataSource) from this file for scanning.
@@ -205,7 +247,13 @@ impl VortexFile {
         let mut ctx = self.session.create_execution_ctx();
         Ok(match applied.execute::<Columnar>(&mut ctx)? {
             Columnar::Constant(s) => s.scalar().as_bool().value() == Some(true),
-            Columnar::Canonical(_) => false,
+            Columnar::Canonical(c) => {
+                c.into_array()
+                    .execute_scalar(0, &mut ctx)?
+                    .as_bool()
+                    .value()
+                    == Some(true)
+            }
         })
     }
 
diff --git a/vortex-file/src/open.rs b/vortex-file/src/open.rs
index 8fb0f22827e..c1793b7b517 100644
--- a/vortex-file/src/open.rs
+++ b/vortex-file/src/open.rs
@@ -60,6 +60,8 @@ pub struct VortexOpenOptions {
     metrics_registry: Option<Arc<dyn MetricsRegistry>>,
     /// Default labels applied to all the file's metrics
     labels: Vec<Label>,
+    /// Whether to cache file's LayoutReader between scans
+    cache_layout_reader: bool,
 }
 
 pub trait OpenOptionsSessionExt:
@@ -77,6 +79,7 @@ pub trait OpenOptionsSessionExt:
             initial_read_segments: Default::default(),
             metrics_registry: None,
             labels: Vec::default(),
+            cache_layout_reader: false,
         }
     }
 }
@@ -92,6 +95,12 @@ impl VortexOpenOptions {
         self
     }
 
+    /// Cache file's LayoutReader between scans
+    pub fn with_layout_reader_cache(mut self) -> Self {
+        self.cache_layout_reader = true;
+        self
+    }
+
     /// Configure a custom [`SegmentCache`].
     pub fn with_segment_cache(mut self, segment_cache: Arc<dyn SegmentCache>) -> Self {
         self.segment_cache = Some(segment_cache);
@@ -182,6 +191,7 @@ impl VortexOpenOptions {
             tracing::warn!("metrics registry is ignored for in-memory `open_buffer`");
         }
 
+        let cache_layout_reader = self.cache_layout_reader;
         let mut opts = self.with_initial_read_size(0);
 
         let footer = match opts.footer.take() {
@@ -193,8 +203,12 @@ impl VortexOpenOptions {
             buffer,
             Arc::clone(footer.segment_map()),
         ));
-
-        Ok(VortexFile::new(footer, segment_source, opts.session))
+        let file = VortexFile::new(footer, segment_source, opts.session);
+        Ok(if cache_layout_reader {
+            file.with_caching()
+        } else {
+            file
+        })
     }
 
     /// An API for opening a [`VortexFile`] using any [`VortexReadAt`] implementation.
@@ -240,11 +254,12 @@ impl VortexOpenOptions {
             segment_source,
         ));
 
-        Ok(VortexFile::new(
-            footer,
-            segment_source,
-            self.session.clone(),
-        ))
+        let file = VortexFile::new(footer, segment_source, self.session.clone());
+        Ok(if self.cache_layout_reader {
+            file.with_caching()
+        } else {
+            file
+        })
     }
 
     async fn read_footer(&self, read: &dyn VortexReadAt) -> VortexResult<Footer> {
diff --git a/vortex-file/src/segments/source.rs b/vortex-file/src/segments/source.rs
index 277441eb5db..c44cbf0e411 100644
--- a/vortex-file/src/segments/source.rs
+++ b/vortex-file/src/segments/source.rs
@@ -148,7 +148,7 @@ impl FileSegmentSource {
 
 impl SegmentSource for FileSegmentSource {
     fn request(&self, id: SegmentId) -> SegmentFuture {
-        // We eagerly register the read request here assuming the behaviour of [`FileRead`], where
+        // We eagerly register the read request here assuming the behaviour of [`FileSegmentSource`], where
         // coalescing becomes effective prior to the future being polled.
         let spec = *match self.segments.get(*id as usize) {
             Some(spec) => spec,
@@ -191,9 +191,9 @@ impl SegmentSource for FileSegmentSource {
     }
 }
 
-/// A future that resolves a read request from a [`FileRead`].
+/// A future that resolves a read request from a [`FileSegmentSource`].
 ///
-/// See the documentation for [`FileRead`] for details on coalescing and pre-fetching.
+/// See the documentation for [`FileSegmentSource`] for details on coalescing and pre-fetching.
 /// If dropped, the read request will be canceled where possible.
 struct ReadFuture {
     id: usize,
diff --git a/vortex-file/src/tests.rs b/vortex-file/src/tests.rs
index 2ba10d96684..e320cf2e9d9 100644
--- a/vortex-file/src/tests.rs
+++ b/vortex-file/src/tests.rs
@@ -35,6 +35,7 @@ use vortex_array::dtype::PType::I32;
 use vortex_array::dtype::StructFields;
 use vortex_array::expr::and;
 use vortex_array::expr::cast;
+use vortex_array::expr::col;
 use vortex_array::expr::eq;
 use vortex_array::expr::get_item;
 use vortex_array::expr::gt;
@@ -1953,3 +1954,39 @@ async fn test_segment_ordering_zonemaps_after_data() -> VortexResult<()> {
 
     Ok(())
 }
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)]
+async fn test_can_prune_composite_predicates() -> VortexResult<()> {
+    // Regression test for `can_prune` after `ScalarFnConstantRule` was removed
+    // (#7575): composite falsification trees no longer constant-fold during
+    // execution, so `can_prune` must read the one-row evaluated result instead
+    // of requiring a `Columnar::Constant`. `Eq` is affected too: its
+    // falsification is internally `or(min > lit, lit > max)`.
+    let st = StructArray::from_fields(&[
+        ("age", buffer![15i32, 18, 22, 25].into_array()),
+        ("price", buffer![120i32, 130, 140, 150].into_array()),
+    ])?;
+    let mut buf = ByteBufferMut::empty();
+    SESSION
+        .write_options()
+        .write(&mut buf, st.into_array().to_array_stream())
+        .await?;
+    let file = SESSION.open_options().open_buffer(buf)?;
+
+    // Bare comparisons: falsified directly by min/max stats.
+    assert!(file.can_prune(&gt(col("age"), lit(30)))?);
+    assert!(file.can_prune(&lt(col("price"), lit(100)))?);
+
+    // Composite predicates whose falsifications are boolean trees.
+    assert!(file.can_prune(&and(gt(col("age"), lit(30)), lt(col("price"), lit(100))))?);
+    assert!(file.can_prune(&or(gt(col("age"), lit(30)), lt(col("age"), lit(10))))?);
+    assert!(file.can_prune(&eq(col("age"), lit(5)))?);
+
+    // Non-falsifiable controls: rows may match, so pruning must refuse.
+    assert!(!file.can_prune(&gt(col("age"), lit(20)))?);
+    assert!(!file.can_prune(&eq(col("age"), lit(18)))?);
+    assert!(!file.can_prune(&and(gt(col("age"), lit(20)), gt(col("price"), lit(100))))?);
+
+    Ok(())
+}
diff --git a/vortex-file/src/v2/file_stats_reader.rs b/vortex-file/src/v2/file_stats_reader.rs
index a6ab9ec79df..0121c12b07d 100644
--- a/vortex-file/src/v2/file_stats_reader.rs
+++ b/vortex-file/src/v2/file_stats_reader.rs
@@ -310,7 +310,7 @@ mod tests {
                 )
                 .await?;
 
-            let child = layout.new_reader("".into(), segments, &SESSION)?;
+            let child = layout.new_reader("".into(), segments, &SESSION, &Default::default())?;
 
             let reader =
                 FileStatsLayoutReader::new(child, test_file_stats(0, 100), SESSION.clone());
@@ -349,7 +349,7 @@ mod tests {
                 )
                 .await?;
 
-            let child = layout.new_reader("".into(), segments, &SESSION)?;
+            let child = layout.new_reader("".into(), segments, &SESSION, &Default::default())?;
 
             let reader =
                 FileStatsLayoutReader::new(child, test_file_stats(0, 100), SESSION.clone());
@@ -400,7 +400,7 @@ mod tests {
                 )
                 .await?;
 
-            let child = layout.new_reader("".into(), segments, &SESSION)?;
+            let child = layout.new_reader("".into(), segments, &SESSION, &Default::default())?;
 
             // File-level stats: 1 null in deleted_at.
             let mut stats = StatsSet::default();
@@ -449,7 +449,7 @@ mod tests {
                 )
                 .await?;
 
-            let child = layout.new_reader("".into(), segments, &SESSION)?;
+            let child = layout.new_reader("".into(), segments, &SESSION, &Default::default())?;
 
             let reader =
                 FileStatsLayoutReader::new(child, test_file_null_count_stats(5), SESSION.clone());
diff --git a/vortex-geo/Cargo.toml b/vortex-geo/Cargo.toml
new file mode 100644
index 00000000000..4e76e2eefcb
--- /dev/null
+++ b/vortex-geo/Cargo.toml
@@ -0,0 +1,31 @@
+[package]
+name = "vortex-geo"
+description = "Geospatial encodings and layouts for Vortex files"
+authors.workspace = true
+categories.workspace = true
+edition.workspace = true
+homepage.workspace = true
+include.workspace = true
+keywords.workspace = true
+license.workspace = true
+readme.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[dependencies]
+arrow-array = { workspace = true }
+arrow-schema = { workspace = true }
+geoarrow = { workspace = true }
+prost = { workspace = true }
+vortex-array = { workspace = true }
+vortex-error = { workspace = true }
+vortex-session = { workspace = true }
+wkb = { workspace = true }
+
+[dev-dependencies]
+geo-traits = { workspace = true }
+geo-types = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/vortex-geo/README.md b/vortex-geo/README.md
new file mode 100644
index 00000000000..139a49323a3
--- /dev/null
+++ b/vortex-geo/README.md
@@ -0,0 +1,7 @@
+# vortex-geo
+
+Geospatial data types and layouts for Vortex. This crate is the Vortex-equivalent of the
+[geoarrow](https://github.com/geoarrow/geoarrow-rs) series of crates.
+
+You can import this crate into your application to add support for reading/write geospatial Vector
+data as part of Vortex files.
\ No newline at end of file
diff --git a/vortex-geo/public-api.lock b/vortex-geo/public-api.lock
new file mode 100644
index 00000000000..3d399aace98
--- /dev/null
+++ b/vortex-geo/public-api.lock
@@ -0,0 +1,127 @@
+pub mod vortex_geo
+
+pub mod vortex_geo::extension
+
+pub struct vortex_geo::extension::GeoMetadata
+
+pub vortex_geo::extension::GeoMetadata::crs: core::option::Option<alloc::string::String>
+
+impl vortex_geo::extension::GeoMetadata
+
+pub fn vortex_geo::extension::GeoMetadata::crs(&self) -> &str
+
+impl core::clone::Clone for vortex_geo::extension::GeoMetadata
+
+pub fn vortex_geo::extension::GeoMetadata::clone(&self) -> vortex_geo::extension::GeoMetadata
+
+impl core::cmp::Eq for vortex_geo::extension::GeoMetadata
+
+impl core::cmp::PartialEq for vortex_geo::extension::GeoMetadata
+
+pub fn vortex_geo::extension::GeoMetadata::eq(&self, &vortex_geo::extension::GeoMetadata) -> bool
+
+impl core::default::Default for vortex_geo::extension::GeoMetadata
+
+pub fn vortex_geo::extension::GeoMetadata::default() -> Self
+
+impl core::fmt::Debug for vortex_geo::extension::GeoMetadata
+
+pub fn vortex_geo::extension::GeoMetadata::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::fmt::Display for vortex_geo::extension::GeoMetadata
+
+pub fn vortex_geo::extension::GeoMetadata::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_geo::extension::GeoMetadata
+
+pub fn vortex_geo::extension::GeoMetadata::hash<__H: core::hash::Hasher>(&self, &mut __H)
+
+impl core::marker::StructuralPartialEq for vortex_geo::extension::GeoMetadata
+
+impl prost::message::Message for vortex_geo::extension::GeoMetadata
+
+pub fn vortex_geo::extension::GeoMetadata::clear(&mut self)
+
+pub fn vortex_geo::extension::GeoMetadata::encoded_len(&self) -> usize
+
+pub struct vortex_geo::extension::WellKnownBinary
+
+impl core::clone::Clone for vortex_geo::extension::WellKnownBinary
+
+pub fn vortex_geo::extension::WellKnownBinary::clone(&self) -> vortex_geo::extension::WellKnownBinary
+
+impl core::cmp::Eq for vortex_geo::extension::WellKnownBinary
+
+impl core::cmp::PartialEq for vortex_geo::extension::WellKnownBinary
+
+pub fn vortex_geo::extension::WellKnownBinary::eq(&self, &vortex_geo::extension::WellKnownBinary) -> bool
+
+impl core::default::Default for vortex_geo::extension::WellKnownBinary
+
+pub fn vortex_geo::extension::WellKnownBinary::default() -> vortex_geo::extension::WellKnownBinary
+
+impl core::fmt::Debug for vortex_geo::extension::WellKnownBinary
+
+pub fn vortex_geo::extension::WellKnownBinary::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl core::hash::Hash for vortex_geo::extension::WellKnownBinary
+
+pub fn vortex_geo::extension::WellKnownBinary::hash<__H: core::hash::Hasher>(&self, &mut __H)
+
+impl core::marker::StructuralPartialEq for vortex_geo::extension::WellKnownBinary
+
+impl vortex_array::dtype::extension::vtable::ExtVTable for vortex_geo::extension::WellKnownBinary
+
+pub type vortex_geo::extension::WellKnownBinary::Metadata = vortex_geo::extension::GeoMetadata
+
+pub type vortex_geo::extension::WellKnownBinary::NativeValue<'a> = vortex_geo::extension::Wkb<'a>
+
+pub fn vortex_geo::extension::WellKnownBinary::deserialize_metadata(&self, &[u8]) -> vortex_error::VortexResult<Self::Metadata>
+
+pub fn vortex_geo::extension::WellKnownBinary::id(&self) -> vortex_array::dtype::extension::ExtId
+
+pub fn vortex_geo::extension::WellKnownBinary::serialize_metadata(&self, &Self::Metadata) -> vortex_error::VortexResult<alloc::vec::Vec<u8>>
+
+pub fn vortex_geo::extension::WellKnownBinary::unpack_native<'a>(&'a vortex_array::dtype::extension::typed::ExtDType<Self>, &'a vortex_array::scalar::scalar_value::ScalarValue) -> vortex_error::VortexResult<Self::NativeValue>
+
+pub fn vortex_geo::extension::WellKnownBinary::validate_dtype(&vortex_array::dtype::extension::typed::ExtDType<Self>) -> vortex_error::VortexResult<()>
+
+pub struct vortex_geo::extension::WellKnownBinaryData
+
+impl vortex_geo::extension::WellKnownBinaryData
+
+pub fn vortex_geo::extension::WellKnownBinaryData::geo_metadata(&self) -> &vortex_geo::extension::GeoMetadata
+
+pub fn vortex_geo::extension::WellKnownBinaryData::wkb_values(&self) -> &vortex_array::array::erased::ArrayRef
+
+impl core::clone::Clone for vortex_geo::extension::WellKnownBinaryData
+
+pub fn vortex_geo::extension::WellKnownBinaryData::clone(&self) -> vortex_geo::extension::WellKnownBinaryData
+
+impl core::convert::TryFrom<vortex_array::array::typed::Array<vortex_array::arrays::extension::vtable::Extension>> for vortex_geo::extension::WellKnownBinaryData
+
+pub type vortex_geo::extension::WellKnownBinaryData::Error = vortex_error::VortexError
+
+pub fn vortex_geo::extension::WellKnownBinaryData::try_from(vortex_array::arrays::extension::vtable::ExtensionArray) -> core::result::Result<Self, Self::Error>
+
+impl core::fmt::Debug for vortex_geo::extension::WellKnownBinaryData
+
+pub fn vortex_geo::extension::WellKnownBinaryData::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+pub struct vortex_geo::extension::Wkb<'a>(_)
+
+impl<'a> vortex_geo::extension::Wkb<'a>
+
+pub fn vortex_geo::extension::Wkb<'a>::try_from_bytes(&'a [u8]) -> vortex_error::VortexResult<Self>
+
+impl<'a> core::fmt::Display for vortex_geo::extension::Wkb<'a>
+
+pub fn vortex_geo::extension::Wkb<'a>::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl<'a> core::ops::deref::Deref for vortex_geo::extension::Wkb<'a>
+
+pub type vortex_geo::extension::Wkb<'a>::Target = wkb::reader::geometry::Wkb<'a>
+
+pub fn vortex_geo::extension::Wkb<'a>::deref(&self) -> &wkb::reader::geometry::Wkb<'a>
+
+pub fn vortex_geo::initialize(&vortex_session::VortexSession)
diff --git a/vortex-geo/src/extension/coordinate.rs b/vortex-geo/src/extension/coordinate.rs
new file mode 100644
index 00000000000..5624886dbb5
--- /dev/null
+++ b/vortex-geo/src/extension/coordinate.rs
@@ -0,0 +1,257 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Coordinate building blocks for geometry extension types: the `Struct<x, y[, z][, m]>` storage
+//! of non-nullable `f64` fields, its [`Dimension`], and the decoded [`Coordinate`] value.
+//!
+//! The coordinate fields are:
+//! - `x` — longitude or easting
+//! - `y` — latitude or northing
+//! - `z` (optional) — elevation
+//! - `m` (optional) — measure: an arbitrary per-point value such as distance along a route or a
+//!   timestamp
+
+use std::fmt::Display;
+use std::fmt::Formatter;
+
+use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
+use vortex_array::arrays::ExtensionArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::StructArray;
+use vortex_array::arrays::extension::ExtensionArrayExt;
+use vortex_array::arrays::struct_::StructArrayExt;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::FieldNames;
+use vortex_array::dtype::Nullability;
+use vortex_array::dtype::PType;
+use vortex_array::scalar::Scalar;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_err;
+
+/// Coordinate dimensions, matching GeoArrow. Field order is fixed: `x`, `y`, then `z` before `m`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum Dimension {
+    /// 2D: `x`, `y`.
+    Xy,
+    /// 3D with elevation: `x`, `y`, `z`.
+    Xyz,
+    /// 3D with a measure: `x`, `y`, `m`.
+    Xym,
+    /// 4D: `x`, `y`, `z`, `m`.
+    Xyzm,
+}
+
+impl Dimension {
+    /// Recover the dimension from a coordinate's field names, in GeoArrow order.
+    pub(crate) fn from_field_names(names: &FieldNames) -> VortexResult<Dimension> {
+        let mut strs = [""; 4];
+        vortex_ensure!(
+            names.len() <= strs.len(),
+            "not a valid GeoArrow coordinate dimension: {names:?}"
+        );
+        for (slot, name) in strs.iter_mut().zip(names.iter()) {
+            *slot = name.as_ref();
+        }
+        Ok(match &strs[..names.len()] {
+            ["x", "y"] => Dimension::Xy,
+            ["x", "y", "z"] => Dimension::Xyz,
+            ["x", "y", "m"] => Dimension::Xym,
+            ["x", "y", "z", "m"] => Dimension::Xyzm,
+            _ => vortex_bail!("not a valid GeoArrow coordinate dimension: {names:?}"),
+        })
+    }
+}
+
+/// A decoded coordinate. `z`/`m` are `Some` iff the storage dimension includes them.
+///
+/// This is the native value produced when unpacking a [`Point`](crate::extension::Point) scalar;
+/// the rest of the coordinate machinery is crate-internal.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Coordinate {
+    /// The x (longitude/easting) ordinate.
+    pub x: f64,
+    /// The y (latitude/northing) ordinate.
+    pub y: f64,
+    /// The optional `z` (elevation) ordinate.
+    pub z: Option<f64>,
+    /// The optional `m` (measure) ordinate.
+    pub m: Option<f64>,
+}
+
+impl Coordinate {
+    /// A 2D coordinate (`z`/`m` unset).
+    pub fn xy(x: f64, y: f64) -> Self {
+        Coordinate {
+            x,
+            y,
+            z: None,
+            m: None,
+        }
+    }
+}
+
+impl Display for Coordinate {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> std::fmt::Result {
+        match (self.z, self.m) {
+            (None, None) => write!(fmt, "POINT({} {})", self.x, self.y),
+            (Some(z), None) => write!(fmt, "POINT Z ({} {} {})", self.x, self.y, z),
+            (None, Some(m)) => write!(fmt, "POINT M ({} {} {})", self.x, self.y, m),
+            (Some(z), Some(m)) => write!(fmt, "POINT ZM ({} {} {} {})", self.x, self.y, z, m),
+        }
+    }
+}
+
+/// Validate that `dtype` is a coordinate struct of non-nullable `f64` fields, returning its
+/// [`Dimension`]. Any of the four GeoArrow dimensions validates.
+pub(crate) fn coordinate_dimension(dtype: &DType) -> VortexResult<Dimension> {
+    let DType::Struct(fields, _) = dtype else {
+        vortex_bail!("coordinate storage must be a Struct, was {dtype}");
+    };
+    for (name, field) in fields.names().iter().zip(fields.fields()) {
+        vortex_ensure!(
+            matches!(
+                field,
+                DType::Primitive(PType::F64, Nullability::NonNullable)
+            ),
+            "coordinate field {name} must be non-nullable f64, was {field}"
+        );
+    }
+    Dimension::from_field_names(fields.names())
+}
+
+/// Decode a [`Coordinate`] from a coordinate `Struct<x, y[, z][, m]>` scalar (`z`/`m` read iff
+/// present, so the same decoder serves every dimension).
+pub(crate) fn coordinate_from_struct(scalar: &Scalar) -> VortexResult<Coordinate> {
+    let fields = scalar.as_struct();
+    let required = |name: &str| -> VortexResult<f64> {
+        f64::try_from(
+            &fields
+                .field(name)
+                .ok_or_else(|| vortex_err!("coordinate missing {name}"))?,
+        )
+    };
+    let optional = |name: &str| -> VortexResult<Option<f64>> {
+        fields
+            .field(name)
+            .map(|value| f64::try_from(&value))
+            .transpose()
+    };
+    Ok(Coordinate {
+        x: required("x")?,
+        y: required("y")?,
+        z: optional("z")?,
+        m: optional("m")?,
+    })
+}
+
+/// Decode a [`Coordinate`] from an extension-typed point scalar (unwrapped to its coordinate
+/// storage) or a bare coordinate `Struct` scalar. The per-row decode used by the distance fns.
+pub(crate) fn coordinate_from_scalar(scalar: &Scalar) -> VortexResult<Coordinate> {
+    match scalar.as_extension_opt() {
+        Some(ext_scalar) => coordinate_from_struct(&ext_scalar.to_storage_scalar()),
+        None => coordinate_from_struct(scalar),
+    }
+}
+
+/// Validated, executed `x`/`y` columns of a point array. The bulk counterpart to [`Coordinate`];
+/// `z`/`m` are not executed.
+pub(crate) struct ParsedCoordinates {
+    /// The flat `f64` `x` column.
+    pub(crate) xs: PrimitiveArray,
+    /// The flat `f64` `y` column.
+    pub(crate) ys: PrimitiveArray,
+}
+
+/// Validate a point column's coordinate storage (layout and non-nullability) and execute its
+/// `x`/`y` columns.
+pub(crate) fn parse_storage(
+    points: &ArrayRef,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ParsedCoordinates> {
+    let storage = points
+        .clone()
+        .execute::<ExtensionArray>(ctx)?
+        .storage_array()
+        .clone()
+        .execute::<StructArray>(ctx)?;
+    coordinate_dimension(storage.dtype())?;
+    vortex_ensure!(
+        !storage.dtype().is_nullable(),
+        "coordinate storage must be non-nullable to read unmasked ordinates, was {}",
+        storage.dtype()
+    );
+    let xs = storage
+        .unmasked_field_by_name("x")?
+        .clone()
+        .execute::<PrimitiveArray>(ctx)?;
+    let ys = storage
+        .unmasked_field_by_name("y")?
+        .clone()
+        .execute::<PrimitiveArray>(ctx)?;
+    Ok(ParsedCoordinates { xs, ys })
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_array::IntoArray;
+    use vortex_array::VortexSessionExecute;
+    use vortex_array::arrays::ExtensionArray;
+    use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::arrays::StructArray;
+    use vortex_array::dtype::FieldNames;
+    use vortex_array::dtype::extension::ExtDType;
+    use vortex_array::session::ArraySession;
+    use vortex_array::validity::Validity;
+    use vortex_error::VortexResult;
+    use vortex_session::VortexSession;
+
+    use super::Coordinate;
+    use super::parse_storage;
+    use crate::extension::GeoMetadata;
+    use crate::extension::Point;
+
+    /// Display emits WKT, including `z`/`m` when present.
+    #[test]
+    fn display_is_wkt() {
+        let coordinate = |z, m| Coordinate {
+            x: 1.0,
+            y: 2.0,
+            z,
+            m,
+        };
+        assert_eq!(coordinate(None, None).to_string(), "POINT(1 2)");
+        assert_eq!(coordinate(Some(3.0), None).to_string(), "POINT Z (1 2 3)");
+        assert_eq!(coordinate(None, Some(4.0)).to_string(), "POINT M (1 2 4)");
+        assert_eq!(
+            coordinate(Some(3.0), Some(4.0)).to_string(),
+            "POINT ZM (1 2 3 4)"
+        );
+    }
+
+    /// [`parse_storage`] reads the coordinate fields unmasked, so a nullable point column must
+    /// be rejected at parse time rather than decoding null rows as garbage ordinates.
+    #[test]
+    fn parse_rejects_nullable_points() -> VortexResult<()> {
+        let session = VortexSession::empty().with::<ArraySession>();
+        let mut ctx = session.create_execution_ctx();
+
+        let storage = StructArray::try_new(
+            FieldNames::from(["x", "y"]),
+            vec![
+                PrimitiveArray::from_iter(vec![1.0f64]).into_array(),
+                PrimitiveArray::from_iter(vec![2.0f64]).into_array(),
+            ],
+            1,
+            Validity::AllValid,
+        )?
+        .into_array();
+        let dtype = ExtDType::<Point>::try_new(GeoMetadata { crs: None }, storage.dtype().clone())?;
+        let points = ExtensionArray::new(dtype.erased(), storage).into_array();
+
+        assert!(parse_storage(&points, &mut ctx).is_err());
+        Ok(())
+    }
+}
diff --git a/vortex-geo/src/extension/mod.rs b/vortex-geo/src/extension/mod.rs
new file mode 100644
index 00000000000..d69dd239d14
--- /dev/null
+++ b/vortex-geo/src/extension/mod.rs
@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+pub(crate) mod coordinate;
+mod point;
+mod wkb;
+
+use std::fmt::Display;
+
+pub use point::*;
+pub use wkb::*;
+
+/// Extension metadata that is common to all the geospatial extension types.
+///
+/// Currently, this is just the coordinate reference system (CRS).
+/// We may wish to add a second field for edges interpretation in the future similar to
+/// the GeoArrow standard.
+#[derive(Clone, PartialEq, Eq, Hash, prost::Message)]
+pub struct GeoMetadata {
+    #[prost(optional, string, tag = "1")]
+    pub crs: Option<String>,
+}
+
+impl Display for GeoMetadata {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self.crs.as_ref() {
+            Some(crs) => write!(f, "Geometry(crs={crs})"),
+            None => write!(f, "Geometry(unreferenced)"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use prost::Message;
+
+    use crate::extension::GeoMetadata;
+
+    #[test]
+    fn test_metadata() {
+        let meta = GeoMetadata {
+            crs: Some("EPSG:4326".to_string()),
+        };
+
+        assert_eq!(meta.to_string(), "Geometry(crs=EPSG:4326)");
+        // round trip
+        let bytes = meta.encode_to_vec();
+        let decoded = GeoMetadata::decode(bytes.as_slice()).unwrap();
+        assert_eq!(decoded, meta);
+    }
+}
diff --git a/vortex-geo/src/extension/point.rs b/vortex-geo/src/extension/point.rs
new file mode 100644
index 00000000000..119de3a7e45
--- /dev/null
+++ b/vortex-geo/src/extension/point.rs
@@ -0,0 +1,165 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! The [`Point`] geometry extension type (`vortex.geo.point`): a location stored columnarly as
+//! `Struct<x, y[, z][, m]>` of non-nullable `f64` — the four GeoArrow dimensions XY, XYZ, XYM,
+//! XYZM — tagged with [`GeoMetadata`] (CRS). `z` is an optional elevation and `m` an optional
+//! measure: an arbitrary per-point value such as distance along a route or a timestamp.
+
+use prost::Message;
+use vortex_array::dtype::extension::ExtDType;
+use vortex_array::dtype::extension::ExtId;
+use vortex_array::dtype::extension::ExtVTable;
+use vortex_array::scalar::Scalar;
+use vortex_array::scalar::ScalarValue;
+use vortex_error::VortexResult;
+
+use super::GeoMetadata;
+use super::coordinate::Coordinate;
+use super::coordinate::coordinate_dimension;
+use super::coordinate::coordinate_from_struct;
+
+/// A single location: `geoarrow.point`, stored as `Struct<x, y[, z][, m]>` of non-nullable `f64`.
+#[derive(Debug, Clone, Default, PartialEq, Eq, Hash)]
+pub struct Point;
+
+impl ExtVTable for Point {
+    type Metadata = GeoMetadata;
+    type NativeValue<'a> = Coordinate;
+
+    fn id(&self) -> ExtId {
+        ExtId::new_static("vortex.geo.point")
+    }
+
+    fn serialize_metadata(&self, metadata: &Self::Metadata) -> VortexResult<Vec<u8>> {
+        Ok(metadata.encode_to_vec())
+    }
+
+    fn deserialize_metadata(&self, metadata: &[u8]) -> VortexResult<Self::Metadata> {
+        Ok(GeoMetadata::decode(metadata)?)
+    }
+
+    fn validate_dtype(ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
+        coordinate_dimension(ext_dtype.storage_dtype()).map(|_| ())
+    }
+
+    fn unpack_native<'a>(
+        ext_dtype: &'a ExtDType<Self>,
+        storage_value: &'a ScalarValue,
+    ) -> VortexResult<Coordinate> {
+        let storage = Scalar::try_new(
+            ext_dtype.storage_dtype().clone(),
+            Some(storage_value.clone()),
+        )?;
+        coordinate_from_struct(&storage)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_array::IntoArray;
+    use vortex_array::VortexSessionExecute;
+    use vortex_array::arrays::ExtensionArray;
+    use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::arrays::StructArray;
+    use vortex_array::dtype::DType;
+    use vortex_array::dtype::FieldNames;
+    use vortex_array::dtype::Nullability;
+    use vortex_array::dtype::PType;
+    use vortex_array::dtype::StructFields;
+    use vortex_array::dtype::extension::ExtDType;
+    use vortex_array::session::ArraySession;
+    use vortex_error::VortexResult;
+    use vortex_session::VortexSession;
+
+    use super::Point;
+    use crate::extension::GeoMetadata;
+    use crate::extension::coordinate::Coordinate;
+    use crate::extension::coordinate::Dimension;
+    use crate::extension::coordinate::coordinate_dimension;
+    use crate::extension::coordinate::coordinate_from_scalar;
+
+    fn geo_meta() -> GeoMetadata {
+        GeoMetadata {
+            crs: Some("EPSG:4326".to_string()),
+        }
+    }
+
+    /// A coordinate storage dtype with the given field names, non-nullable `f64` per field.
+    fn coordinate_dtype(names: &[&'static str]) -> DType {
+        let fields = std::iter::repeat_n(
+            DType::Primitive(PType::F64, Nullability::NonNullable),
+            names.len(),
+        )
+        .collect::<Vec<_>>();
+        DType::Struct(
+            StructFields::new(FieldNames::from(names), fields),
+            Nullability::NonNullable,
+        )
+    }
+
+    /// `Point` accepts every GeoArrow dimension; the canonical field names round-trip to their
+    /// dimension, so a `z`/`m` swap or a mislabel would be caught.
+    #[test]
+    fn point_validates_every_dimension() -> VortexResult<()> {
+        let cases = [
+            (Dimension::Xy, ["x", "y"].as_slice()),
+            (Dimension::Xyz, ["x", "y", "z"].as_slice()),
+            (Dimension::Xym, ["x", "y", "m"].as_slice()),
+            (Dimension::Xyzm, ["x", "y", "z", "m"].as_slice()),
+        ];
+        for (dim, names) in cases {
+            let storage = coordinate_dtype(names);
+            assert_eq!(coordinate_dimension(&storage)?, dim);
+            ExtDType::<Point>::try_new(geo_meta(), storage)?;
+        }
+        Ok(())
+    }
+
+    /// Invalid storage is rejected at dtype construction: both non-struct storage and a struct whose
+    /// fields are not GeoArrow coordinates.
+    #[test]
+    fn point_rejects_invalid_storage() -> VortexResult<()> {
+        let primitive = DType::Primitive(PType::F64, Nullability::NonNullable);
+        assert!(ExtDType::<Point>::try_new(geo_meta(), primitive).is_err());
+
+        let wrong_fields = StructArray::from_fields(&[
+            ("a", PrimitiveArray::from_iter(vec![0.0f64]).into_array()),
+            ("b", PrimitiveArray::from_iter(vec![0.0f64]).into_array()),
+        ])?
+        .into_array();
+        assert!(ExtDType::<Point>::try_new(geo_meta(), wrong_fields.dtype().clone()).is_err());
+        Ok(())
+    }
+
+    /// A `Point` column round-trips through scalar execution back to the original coordinates.
+    #[test]
+    fn point_unpacks_coordinates() -> VortexResult<()> {
+        let session = VortexSession::empty().with::<ArraySession>();
+        let mut ctx = session.create_execution_ctx();
+
+        let storage = StructArray::from_fields(&[
+            (
+                "x",
+                PrimitiveArray::from_iter(vec![1.0f64, -111.7610]).into_array(),
+            ),
+            (
+                "y",
+                PrimitiveArray::from_iter(vec![2.0f64, 34.8697]).into_array(),
+            ),
+        ])?
+        .into_array();
+        let dtype = ExtDType::<Point>::try_new(geo_meta(), storage.dtype().clone())?;
+        let points = ExtensionArray::new(dtype.erased(), storage).into_array();
+
+        assert_eq!(
+            coordinate_from_scalar(&points.execute_scalar(0, &mut ctx)?)?,
+            Coordinate::xy(1.0, 2.0)
+        );
+        assert_eq!(
+            coordinate_from_scalar(&points.execute_scalar(1, &mut ctx)?)?,
+            Coordinate::xy(-111.7610, 34.8697)
+        );
+        Ok(())
+    }
+}
diff --git a/vortex-geo/src/extension/wkb.rs b/vortex-geo/src/extension/wkb.rs
new file mode 100644
index 00000000000..172da41b93b
--- /dev/null
+++ b/vortex-geo/src/extension/wkb.rs
@@ -0,0 +1,317 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt::Display;
+use std::ops::Deref;
+use std::sync::Arc;
+
+use arrow_array::ArrayRef as ArrowArrayRef;
+use arrow_schema::DataType;
+use arrow_schema::Field;
+use arrow_schema::extension::ExtensionType;
+use geoarrow::array::GenericWkbArray;
+use geoarrow::array::IntoArrow;
+use geoarrow::array::WkbViewArray;
+use geoarrow::datatypes::Crs;
+use geoarrow::datatypes::Metadata;
+use geoarrow::datatypes::WkbType;
+use prost::Message;
+use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
+use vortex_array::arrays::ExtensionArray;
+use vortex_array::arrays::extension::ExtensionArrayExt;
+use vortex_array::arrow::ArrowExport;
+use vortex_array::arrow::ArrowExportVTable;
+use vortex_array::arrow::ArrowImport;
+use vortex_array::arrow::ArrowImportVTable;
+use vortex_array::arrow::ArrowSession;
+use vortex_array::arrow::ArrowSessionExt;
+use vortex_array::arrow::FromArrowArray;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::extension::ExtDType;
+use vortex_array::dtype::extension::ExtId;
+use vortex_array::dtype::extension::ExtVTable;
+use vortex_array::scalar::ScalarValue;
+use vortex_error::VortexError;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_ensure;
+use vortex_error::vortex_err;
+use vortex_session::registry::CachedId;
+use vortex_session::registry::Id;
+use wkb::reader::GeometryType;
+
+use crate::extension::GeoMetadata;
+
+/// A typed handle to an [`ExtensionArray`] that contains WKB-encoded data.
+///
+/// You can construct this safely using `WellKnownBinaryData::try_from(ExtensionArray)`.
+#[derive(Debug, Clone)]
+pub struct WellKnownBinaryData {
+    ext: ExtensionArray,
+}
+
+impl WellKnownBinaryData {
+    /// A reference to the array that holds the Well-Known Binary scalar values.
+    pub fn wkb_values(&self) -> &ArrayRef {
+        self.ext.storage_array()
+    }
+
+    /// A reference to the [geospatial metadata][GeoMetadata].
+    pub fn geo_metadata(&self) -> &GeoMetadata {
+        self.ext
+            .dtype()
+            .as_extension()
+            .metadata::<WellKnownBinary>()
+    }
+}
+
+impl TryFrom<ExtensionArray> for WellKnownBinaryData {
+    type Error = VortexError;
+
+    fn try_from(ext: ExtensionArray) -> Result<Self, Self::Error> {
+        if !ext.ext_dtype().is::<WellKnownBinary>() {
+            vortex_bail!("array extension dtype {} is not a WKB", ext.ext_dtype());
+        }
+
+        Ok(Self { ext })
+    }
+}
+
+/// An [extension type][ExtVTable] for OGC Well-known Binary (WKB) data format.
+///
+/// This is one of the most common formats for sharing of geometry data between analytic systems,
+/// used by DuckDB, PostGIS and GeoParquet.
+#[derive(Debug, Clone, Default, PartialEq, Eq, Hash)]
+pub struct WellKnownBinary;
+
+/// A reference to a value of well-known binary encoded geometry data.
+///
+/// Interpreting this value is dependent on the [geospatial metadata][GeoMetadata] in the extension
+/// schema for the array where this scalar is taken from.
+pub struct Wkb<'a>(wkb::reader::Wkb<'a>);
+
+impl<'a> Wkb<'a> {
+    /// Attempt to decode a well-known binary value from a byte slice.
+    ///
+    /// This will not cause any data allocations or copies, but it will perform a one-pass
+    /// validation on the structure of the WKB.
+    pub fn try_from_bytes(bytes: &'a [u8]) -> VortexResult<Self> {
+        wkb::reader::Wkb::try_new(bytes)
+            .map_err(|e| vortex_err!("failed parsing WKB: {e}"))
+            .map(Wkb)
+    }
+}
+
+impl<'a> Display for Wkb<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let geometry_kind = match self.0.geometry_type() {
+            GeometryType::Point => "point",
+            GeometryType::LineString => "linestring",
+            GeometryType::Polygon => "polygon",
+            GeometryType::MultiPoint => "multipoint",
+            GeometryType::MultiLineString => "multilinestring",
+            GeometryType::MultiPolygon => "multipolygon",
+            GeometryType::GeometryCollection => "geometrycollection",
+            _ => "unknown",
+        };
+        // TODO(aduffy): make this more useful
+        write!(f, "WKB({geometry_kind})")
+    }
+}
+
+impl<'a> Deref for Wkb<'a> {
+    type Target = wkb::reader::Wkb<'a>;
+
+    fn deref(&self) -> &wkb::reader::Wkb<'a> {
+        &self.0
+    }
+}
+
+impl ExtVTable for WellKnownBinary {
+    type Metadata = GeoMetadata;
+
+    type NativeValue<'a> = Wkb<'a>;
+
+    fn id(&self) -> ExtId {
+        ExtId::new_static("vortex.geo.wkb")
+    }
+
+    fn serialize_metadata(&self, metadata: &Self::Metadata) -> VortexResult<Vec<u8>> {
+        Ok(metadata.encode_to_vec())
+    }
+
+    fn deserialize_metadata(&self, metadata: &[u8]) -> VortexResult<Self::Metadata> {
+        Ok(GeoMetadata::decode(metadata)?)
+    }
+
+    fn validate_dtype(ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
+        vortex_ensure!(
+            ext_dtype.storage_dtype().is_binary(),
+            "geo.wkb must have binary storage type, was {}",
+            ext_dtype.storage_dtype()
+        );
+
+        Ok(())
+    }
+
+    fn unpack_native<'a>(
+        _ext_dtype: &'a ExtDType<Self>,
+        storage_value: &'a ScalarValue,
+    ) -> VortexResult<Self::NativeValue<'a>> {
+        Wkb::try_from_bytes(storage_value.as_binary().as_slice())
+    }
+}
+
+static ARROW_WKB: CachedId = CachedId::new(WkbType::NAME);
+
+impl ArrowExportVTable for WellKnownBinary {
+    fn arrow_ext_id(&self) -> Id {
+        *ARROW_WKB
+    }
+
+    fn vortex_id(&self) -> Id {
+        self.id()
+    }
+
+    fn to_arrow_field(
+        &self,
+        name: &str,
+        dtype: &DType,
+        session: &ArrowSession,
+    ) -> VortexResult<Option<Field>> {
+        let ext_type = dtype.as_extension();
+        let geo_metadata = ext_type.metadata::<WellKnownBinary>();
+
+        let mut field = session.to_arrow_field(name, ext_type.storage_dtype())?;
+        field.try_with_extension_type(wkb_type(geo_metadata))?;
+
+        Ok(Some(field))
+    }
+
+    fn execute_arrow(
+        &self,
+        array: ArrayRef,
+        target: &Field,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrowExport> {
+        let is_wkb = array
+            .dtype()
+            .as_extension_opt()
+            .map(|ext| ext.is::<WellKnownBinary>())
+            .unwrap_or(false);
+        if !is_wkb {
+            return Ok(ArrowExport::Unsupported(array));
+        }
+
+        let Ok(wkb_meta) = target.try_extension_type::<WkbType>() else {
+            return Ok(ArrowExport::Unsupported(array));
+        };
+
+        let executed = array.execute::<ExtensionArray>(ctx)?;
+        let storage = executed.storage_array().clone();
+
+        let storage_field = Field::new(
+            String::new(),
+            target.data_type().clone(),
+            target.is_nullable(),
+        );
+        let session = ctx.session().clone();
+        let arrow_storage = session
+            .arrow()
+            .execute_arrow(storage, Some(&storage_field), ctx)?;
+
+        // Round-trip through the GeoArrow WKB array types: this validates that the storage
+        // is a binary-family Arrow array and produces the canonical physical representation
+        // expected for a `WkbType` extension field.
+        let arrow_ref: ArrowArrayRef = match target.data_type() {
+            DataType::Binary => Arc::new(
+                GenericWkbArray::<i32>::try_from((arrow_storage.as_ref(), wkb_meta))
+                    .map_err(|e| vortex_err!("failed to construct WkbArray: {e}"))?
+                    .into_arrow(),
+            ),
+            DataType::LargeBinary => Arc::new(
+                GenericWkbArray::<i64>::try_from((arrow_storage.as_ref(), wkb_meta))
+                    .map_err(|e| vortex_err!("failed to construct LargeWkbArray: {e}"))?
+                    .into_arrow(),
+            ),
+            DataType::BinaryView => Arc::new(
+                WkbViewArray::try_from((arrow_storage.as_ref(), wkb_meta))
+                    .map_err(|e| vortex_err!("failed to construct WkbViewArray: {e}"))?
+                    .into_arrow(),
+            ),
+            _ => unreachable!("target data type was validated above"),
+        };
+
+        Ok(ArrowExport::Exported(arrow_ref))
+    }
+}
+
+impl ArrowImportVTable for WellKnownBinary {
+    fn arrow_ext_id(&self) -> Id {
+        *ARROW_WKB
+    }
+
+    fn from_arrow_field(&self, field: &Field) -> VortexResult<Option<DType>> {
+        let Ok(wkb_meta) = field.try_extension_type::<WkbType>() else {
+            return Ok(None);
+        };
+
+        let storage_dtype = DType::Binary(field.is_nullable().into());
+        Ok(Some(DType::Extension(
+            ExtDType::try_with_vtable(WellKnownBinary, geo_metadata(&wkb_meta), storage_dtype)?
+                .erased(),
+        )))
+    }
+
+    fn from_arrow_array(
+        &self,
+        array: ArrowArrayRef,
+        field: &Field,
+        dtype: &DType,
+    ) -> VortexResult<ArrowImport> {
+        let Some(ext_dtype) = dtype.as_extension_opt() else {
+            return Ok(ArrowImport::Unsupported(array));
+        };
+        if !ext_dtype.is::<WellKnownBinary>()
+            || field.try_extension_type::<WkbType>().is_err()
+            || !matches!(
+                array.data_type(),
+                DataType::Binary | DataType::LargeBinary | DataType::BinaryView
+            )
+        {
+            return Ok(ArrowImport::Unsupported(array));
+        }
+
+        let storage = ArrayRef::from_arrow(array.as_ref(), field.is_nullable())?;
+        Ok(ArrowImport::Imported(
+            ExtensionArray::new(ext_dtype.clone(), storage).into_array(),
+        ))
+    }
+}
+
+fn wkb_type(geo_metadata: &GeoMetadata) -> WkbType {
+    let metadata = Metadata::new(
+        geo_metadata
+            .crs
+            .as_ref()
+            .map(|crs| Crs::from_unknown_crs_type(crs.to_string()))
+            .unwrap_or_default(),
+        None,
+    );
+    WkbType::new(Arc::new(metadata))
+}
+
+fn geo_metadata(wkb_type: &WkbType) -> GeoMetadata {
+    let crs = wkb_type.metadata().crs().crs_value().map(|value| {
+        // `Crs::from_unknown_crs_type` stores the user's string verbatim as a JSON string
+        // value, so prefer the raw string when available to round-trip cleanly. For other
+        // CRS encodings (PROJJSON object, etc.), fall back to the JSON-encoded form.
+        value
+            .as_str()
+            .map(str::to_string)
+            .unwrap_or_else(|| value.to_string())
+    });
+    GeoMetadata { crs }
+}
diff --git a/vortex-geo/src/lib.rs b/vortex-geo/src/lib.rs
new file mode 100644
index 00000000000..9d0cde26f9e
--- /dev/null
+++ b/vortex-geo/src/lib.rs
@@ -0,0 +1,331 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::sync::Arc;
+
+use vortex_array::arrow::ArrowSessionExt;
+use vortex_array::dtype::session::DTypeSessionExt;
+use vortex_array::scalar_fn::session::ScalarFnSessionExt;
+use vortex_session::VortexSession;
+
+use crate::extension::Point;
+use crate::extension::WellKnownBinary;
+use crate::scalar_fn::distance::GeoDistance;
+
+pub mod extension;
+pub mod scalar_fn;
+/// Set up a session with support for geospatial extension types, encodings and layouts.
+pub fn initialize(session: &VortexSession) {
+    // Register the geospatial extension types.
+    session.dtypes().register(WellKnownBinary);
+    session.arrow().register_exporter(Arc::new(WellKnownBinary));
+    session.arrow().register_importer(Arc::new(WellKnownBinary));
+    session.dtypes().register(Point);
+
+    // Register the geometry scalar functions.
+    session.scalar_fns().register(GeoDistance);
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+    use std::sync::LazyLock;
+
+    use arrow_array::Array as _;
+    use arrow_array::ArrayRef as ArrowArrayRef;
+    use arrow_array::BinaryArray;
+    use arrow_array::BinaryViewArray;
+    use arrow_array::LargeBinaryArray;
+    use arrow_array::cast::AsArray;
+    use arrow_schema::DataType;
+    use arrow_schema::Field;
+    use arrow_schema::extension::ExtensionType as _;
+    use geo_traits::to_geo::ToGeoGeometry;
+    use geo_types::Coord;
+    use geo_types::Geometry;
+    use geo_types::LineString;
+    use geo_types::Polygon;
+    use geoarrow::datatypes::Crs;
+    use geoarrow::datatypes::Metadata;
+    use geoarrow::datatypes::WkbType;
+    use vortex_array::IntoArray;
+    use vortex_array::VortexSessionExecute;
+    use vortex_array::arrays::ExtensionArray;
+    use vortex_array::arrays::varbin::builder::VarBinBuilder;
+    use vortex_array::arrow::ArrowSessionExt;
+    use vortex_array::dtype::DType;
+    use vortex_array::dtype::Nullability;
+    use vortex_array::dtype::extension::ExtDType;
+    use vortex_array::dtype::extension::ExtVTable;
+    use vortex_array::session::ArraySession;
+    use vortex_error::VortexResult;
+    use vortex_error::vortex_err;
+    use vortex_session::VortexSession;
+    use wkb::writer::WriteOptions;
+
+    use crate::extension::GeoMetadata;
+    use crate::extension::WellKnownBinary;
+
+    static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
+        let session = VortexSession::empty().with::<ArraySession>();
+        crate::initialize(&session);
+        session
+    });
+
+    #[test]
+    fn test_array() -> VortexResult<()> {
+        let mut execution_ctx = SESSION.create_execution_ctx();
+
+        let mut buf = Vec::new();
+
+        let mut builder = VarBinBuilder::<i32>::with_capacity(3);
+
+        let polygon = Geometry::Polygon(Polygon::new(
+            LineString::new(vec![
+                Coord::zero(),
+                Coord { x: 100.0, y: 0.0 },
+                Coord { x: 100.0, y: 100.0 },
+                Coord { x: 0.0, y: 100.0 },
+                Coord::zero(),
+            ]),
+            vec![],
+        ));
+
+        // We should always prefer to write little-endian, which is the default option.
+        wkb::writer::write_geometry(&mut buf, &polygon, &WriteOptions::default())
+            .map_err(|e| vortex_err!("writing WKB failed: {e}"))?;
+
+        // Push same polygon 3 times
+        builder.append_value(&buf);
+        builder.append_value(&buf);
+        builder.append_value(&buf);
+
+        let dtype = ExtDType::<WellKnownBinary>::try_new(
+            GeoMetadata {
+                crs: Some("EPSG:4326".to_string()),
+            },
+            DType::Binary(Nullability::NonNullable),
+        )?;
+
+        let array = builder.finish(DType::Binary(Nullability::NonNullable));
+        let array = ExtensionArray::new(dtype.clone().erased(), array.into_array()).into_array();
+
+        for idx in 0..3 {
+            let geom = array.execute_scalar(idx, &mut execution_ctx)?;
+            let wkb = WellKnownBinary::unpack_native(&dtype, geom.value().unwrap())?;
+
+            assert_eq!(wkb.to_geometry(), polygon);
+        }
+
+        Ok(())
+    }
+
+    fn wkb_extension_array() -> VortexResult<(Vec<u8>, vortex_array::ArrayRef)> {
+        let polygon = Geometry::Polygon(Polygon::new(
+            LineString::new(vec![
+                Coord::zero(),
+                Coord { x: 100.0, y: 0.0 },
+                Coord { x: 100.0, y: 100.0 },
+                Coord { x: 0.0, y: 100.0 },
+                Coord::zero(),
+            ]),
+            vec![],
+        ));
+        let mut buf = Vec::new();
+        wkb::writer::write_geometry(&mut buf, &polygon, &WriteOptions::default())
+            .map_err(|e| vortex_err!("writing WKB failed: {e}"))?;
+
+        let mut builder = VarBinBuilder::<i32>::with_capacity(3);
+        builder.append_value(&buf);
+        builder.append_value(&buf);
+        builder.append_value(&buf);
+
+        let dtype = ExtDType::<WellKnownBinary>::try_new(
+            GeoMetadata {
+                crs: Some("EPSG:4326".to_string()),
+            },
+            DType::Binary(Nullability::NonNullable),
+        )?;
+        let storage = builder.finish(DType::Binary(Nullability::NonNullable));
+        let array = ExtensionArray::new(dtype.erased(), storage.into_array()).into_array();
+        Ok((buf, array))
+    }
+
+    #[test]
+    fn export_arrow_field_carries_wkb_extension() -> VortexResult<()> {
+        let (_, array) = wkb_extension_array()?;
+        let field = SESSION.arrow().to_arrow_field("geom", array.dtype())?;
+        assert_eq!(field.extension_type_name(), Some(WkbType::NAME));
+        // Vortex's canonical mapping of `DType::Binary` is Arrow's `BinaryView`.
+        assert_eq!(field.data_type(), &DataType::BinaryView);
+        Ok(())
+    }
+
+    #[test]
+    fn execute_arrow_exports_wkb_to_binary() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
+        let (wkb_bytes, array) = wkb_extension_array()?;
+
+        let field = Field::new("geom", DataType::Binary, false)
+            .with_extension_type(WkbType::new(Default::default()));
+        let exported = SESSION
+            .arrow()
+            .execute_arrow(array, Some(&field), &mut ctx)?;
+
+        assert_eq!(exported.data_type(), &DataType::Binary);
+        let binary = exported.as_binary::<i32>();
+        assert_eq!(binary.len(), 3);
+        for idx in 0..3 {
+            assert_eq!(binary.value(idx), wkb_bytes.as_slice());
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn execute_arrow_exports_wkb_to_large_binary() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
+        let (wkb_bytes, array) = wkb_extension_array()?;
+
+        let field = Field::new("geom", DataType::LargeBinary, false)
+            .with_extension_type(WkbType::new(Default::default()));
+        let exported = SESSION
+            .arrow()
+            .execute_arrow(array, Some(&field), &mut ctx)?;
+
+        assert_eq!(exported.data_type(), &DataType::LargeBinary);
+        let binary = exported.as_binary::<i64>();
+        assert_eq!(binary.len(), 3);
+        for idx in 0..3 {
+            assert_eq!(binary.value(idx), wkb_bytes.as_slice());
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn execute_arrow_exports_wkb_to_binary_view() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
+        let (wkb_bytes, array) = wkb_extension_array()?;
+
+        let field = Field::new("geom", DataType::BinaryView, false)
+            .with_extension_type(WkbType::new(Default::default()));
+        let exported = SESSION
+            .arrow()
+            .execute_arrow(array, Some(&field), &mut ctx)?;
+
+        assert_eq!(exported.data_type(), &DataType::BinaryView);
+        let binary = exported.as_binary_view();
+        assert_eq!(binary.len(), 3);
+        for idx in 0..3 {
+            assert_eq!(binary.value(idx), wkb_bytes.as_slice());
+        }
+        Ok(())
+    }
+
+    fn wkb_field(name: &str, data_type: DataType, nullable: bool, crs: Option<&str>) -> Field {
+        let crs = crs
+            .map(|crs| Crs::from_unknown_crs_type(crs.to_string()))
+            .unwrap_or_default();
+        let wkb_type = WkbType::new(Arc::new(Metadata::new(crs, None)));
+        Field::new(name, data_type, nullable).with_extension_type(wkb_type)
+    }
+
+    fn assert_imported_wkb_dtype(dtype: &DType, expected_crs: Option<&str>, nullable: bool) {
+        let DType::Extension(ext) = dtype else {
+            panic!("expected Extension dtype, got {dtype}");
+        };
+        assert!(ext.is::<WellKnownBinary>());
+        assert_eq!(ext.storage_dtype(), &DType::Binary(nullable.into()));
+        let geo = ext.metadata::<WellKnownBinary>();
+        assert_eq!(geo.crs.as_deref(), expected_crs);
+    }
+
+    #[test]
+    fn import_arrow_field_recovers_wkb_extension() -> VortexResult<()> {
+        let field = wkb_field("geom", DataType::Binary, false, Some("EPSG:4326"));
+        let dtype = SESSION.arrow().from_arrow_field(&field)?;
+        assert_imported_wkb_dtype(&dtype, Some("EPSG:4326"), false);
+        Ok(())
+    }
+
+    #[test]
+    fn import_arrow_field_without_crs() -> VortexResult<()> {
+        let field = wkb_field("geom", DataType::BinaryView, true, None);
+        let dtype = SESSION.arrow().from_arrow_field(&field)?;
+        assert_imported_wkb_dtype(&dtype, None, true);
+        Ok(())
+    }
+
+    #[test]
+    fn import_arrow_array_from_binary() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
+        let (wkb_bytes, _) = wkb_extension_array()?;
+        let arrow: ArrowArrayRef = Arc::new(BinaryArray::from_iter_values([
+            wkb_bytes.as_slice(),
+            wkb_bytes.as_slice(),
+            wkb_bytes.as_slice(),
+        ]));
+        let field = wkb_field("geom", DataType::Binary, false, Some("EPSG:4326"));
+
+        let imported = SESSION.arrow().from_arrow_array(arrow, &field)?;
+        assert_imported_wkb_dtype(imported.dtype(), Some("EPSG:4326"), false);
+
+        for idx in 0..3 {
+            let geom = imported.execute_scalar(idx, &mut ctx)?;
+            assert_eq!(geom.value().unwrap().as_binary().as_slice(), wkb_bytes);
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn import_arrow_array_from_large_binary() -> VortexResult<()> {
+        let (wkb_bytes, _) = wkb_extension_array()?;
+        let arrow: ArrowArrayRef = Arc::new(LargeBinaryArray::from_iter_values([
+            wkb_bytes.as_slice(),
+            wkb_bytes.as_slice(),
+        ]));
+        let field = wkb_field("geom", DataType::LargeBinary, false, Some("EPSG:4326"));
+
+        let imported = SESSION.arrow().from_arrow_array(arrow, &field)?;
+        assert_imported_wkb_dtype(imported.dtype(), Some("EPSG:4326"), false);
+        assert_eq!(imported.len(), 2);
+        Ok(())
+    }
+
+    #[test]
+    fn import_arrow_array_from_binary_view() -> VortexResult<()> {
+        let (wkb_bytes, _) = wkb_extension_array()?;
+        let arrow: ArrowArrayRef = Arc::new(BinaryViewArray::from_iter_values([
+            wkb_bytes.as_slice(),
+            wkb_bytes.as_slice(),
+            wkb_bytes.as_slice(),
+            wkb_bytes.as_slice(),
+        ]));
+        let field = wkb_field("geom", DataType::BinaryView, false, None);
+
+        let imported = SESSION.arrow().from_arrow_array(arrow, &field)?;
+        assert_imported_wkb_dtype(imported.dtype(), None, false);
+        assert_eq!(imported.len(), 4);
+        Ok(())
+    }
+
+    #[test]
+    fn import_arrow_array_roundtrips_through_export() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
+        let (wkb_bytes, original) = wkb_extension_array()?;
+
+        let field = Field::new("geom", DataType::BinaryView, false)
+            .with_extension_type(WkbType::new(Default::default()));
+        let exported = SESSION
+            .arrow()
+            .execute_arrow(original, Some(&field), &mut ctx)?;
+        let arrow_field = wkb_field("geom", DataType::BinaryView, false, Some("EPSG:4326"));
+        let reimported = SESSION.arrow().from_arrow_array(exported, &arrow_field)?;
+
+        assert_imported_wkb_dtype(reimported.dtype(), Some("EPSG:4326"), false);
+        for idx in 0..3 {
+            let geom = reimported.execute_scalar(idx, &mut ctx)?;
+            assert_eq!(geom.value().unwrap().as_binary().as_slice(), wkb_bytes);
+        }
+        Ok(())
+    }
+}
diff --git a/vortex-geo/src/scalar_fn/distance.rs b/vortex-geo/src/scalar_fn/distance.rs
new file mode 100644
index 00000000000..e621c4bbad1
--- /dev/null
+++ b/vortex-geo/src/scalar_fn/distance.rs
@@ -0,0 +1,266 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Straight-line (Euclidean) distance between points; "planar" distance in GIS terms.
+
+use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
+use vortex_array::arrays::Constant;
+use vortex_array::arrays::ConstantArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::ScalarFnArray;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::Nullability;
+use vortex_array::dtype::PType;
+use vortex_array::scalar::Scalar;
+use vortex_array::scalar_fn::Arity;
+use vortex_array::scalar_fn::ChildName;
+use vortex_array::scalar_fn::EmptyOptions;
+use vortex_array::scalar_fn::ExecutionArgs;
+use vortex_array::scalar_fn::ScalarFnId;
+use vortex_array::scalar_fn::ScalarFnVTable;
+use vortex_array::scalar_fn::TypedScalarFnInstance;
+use vortex_error::VortexResult;
+use vortex_session::VortexSession;
+
+use crate::extension::coordinate::coordinate_from_scalar;
+use crate::extension::coordinate::parse_storage;
+
+/// Straight-line (L2) distance between `(ax, ay)` and `(bx, by)`.
+fn euclidean_distance(ax: f64, ay: f64, bx: f64, by: f64) -> f64 {
+    let dx = ax - bx;
+    let dy = ay - by;
+    (dx * dx + dy * dy).sqrt()
+}
+
+/// Straight-line (Euclidean) distance between two point operands — "planar" distance in GIS terms
+/// (e.g. PostGIS `ST_Distance`). No geodesic correction, and `z`/`m` are ignored.
+///
+/// The operands are two point columns of equal length; either (or both) may be constant, in which
+/// case the constant query point is decoded once and broadcast.
+#[derive(Debug, Clone, Default, PartialEq, Eq, Hash)]
+pub struct GeoDistance;
+
+impl GeoDistance {
+    /// A lazy `ScalarFnArray` computing the per-row distance between the point columns `a` and
+    /// `b`; either may be constant. The output length is taken from `a`.
+    pub fn try_new_array(a: ArrayRef, b: ArrayRef) -> VortexResult<ScalarFnArray> {
+        ScalarFnArray::try_new(
+            TypedScalarFnInstance::new(GeoDistance, EmptyOptions).erased(),
+            vec![a, b],
+        )
+    }
+}
+
+impl ScalarFnVTable for GeoDistance {
+    type Options = EmptyOptions;
+
+    fn id(&self) -> ScalarFnId {
+        ScalarFnId::new("vortex.geo.distance")
+    }
+
+    fn serialize(&self, _: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(vec![]))
+    }
+
+    fn deserialize(&self, _: &[u8], _: &VortexSession) -> VortexResult<Self::Options> {
+        Ok(EmptyOptions)
+    }
+
+    fn arity(&self, _: &Self::Options) -> Arity {
+        Arity::Exact(2)
+    }
+
+    fn child_name(&self, _: &Self::Options, child_idx: usize) -> ChildName {
+        match child_idx {
+            0 => ChildName::from("a"),
+            1 => ChildName::from("b"),
+            _ => unreachable!("distance has exactly two children"),
+        }
+    }
+
+    fn return_dtype(&self, _: &Self::Options, _: &[DType]) -> VortexResult<DType> {
+        Ok(DType::Primitive(PType::F64, Nullability::NonNullable))
+    }
+
+    fn execute(
+        &self,
+        _: &Self::Options,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let a = args.get(0)?;
+        let b = args.get(1)?;
+        match (a.as_opt::<Constant>(), b.as_opt::<Constant>()) {
+            (Some(qa), Some(qb)) => {
+                let qa = coordinate_from_scalar(qa.scalar())?;
+                let qb = coordinate_from_scalar(qb.scalar())?;
+                let distance = euclidean_distance(qa.x, qa.y, qb.x, qb.y);
+                Ok(ConstantArray::new(
+                    Scalar::primitive(distance, Nullability::NonNullable),
+                    a.len(),
+                )
+                .into_array())
+            }
+            (Some(query), None) => distances_to_constant(&b, query.scalar(), ctx),
+            (None, Some(query)) => distances_to_constant(&a, query.scalar(), ctx),
+            (None, None) => {
+                let a_coords = parse_storage(&a, ctx)?;
+                let b_coords = parse_storage(&b, ctx)?;
+                let distances = a_coords
+                    .xs
+                    .as_slice::<f64>()
+                    .iter()
+                    .zip(a_coords.ys.as_slice::<f64>())
+                    .zip(
+                        b_coords
+                            .xs
+                            .as_slice::<f64>()
+                            .iter()
+                            .zip(b_coords.ys.as_slice::<f64>()),
+                    )
+                    .map(|((&ax, &ay), (&bx, &by))| euclidean_distance(ax, ay, bx, by));
+                Ok(PrimitiveArray::from_iter(distances).into_array())
+            }
+        }
+    }
+}
+
+/// Distance from each row of `points` to a constant `query` point, decoded once and broadcast.
+/// Distance is symmetric, so this serves a constant on either side.
+fn distances_to_constant(
+    points: &ArrayRef,
+    query: &Scalar,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ArrayRef> {
+    let query = coordinate_from_scalar(query)?;
+    let coords = parse_storage(points, ctx)?;
+    let distances = coords
+        .xs
+        .as_slice::<f64>()
+        .iter()
+        .zip(coords.ys.as_slice::<f64>())
+        .map(|(&x, &y)| euclidean_distance(x, y, query.x, query.y));
+    Ok(PrimitiveArray::from_iter(distances).into_array())
+}
+
+#[cfg(test)]
+mod tests {
+    use vortex_array::ArrayRef;
+    use vortex_array::Canonical;
+    use vortex_array::ExecutionCtx;
+    use vortex_array::IntoArray;
+    use vortex_array::VortexSessionExecute;
+    use vortex_array::arrays::ConstantArray;
+    use vortex_array::arrays::ExtensionArray;
+    use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::arrays::StructArray;
+    use vortex_array::dtype::extension::ExtDType;
+    use vortex_array::session::ArraySession;
+    use vortex_error::VortexResult;
+    use vortex_session::VortexSession;
+
+    use super::GeoDistance;
+    use super::euclidean_distance;
+    use crate::extension::GeoMetadata;
+    use crate::extension::Point;
+
+    /// A `Point` column (CRS `EPSG:4326`) over the given x/y coordinates.
+    fn point_column(xs: Vec<f64>, ys: Vec<f64>) -> VortexResult<ArrayRef> {
+        let storage = StructArray::from_fields(&[
+            ("x", PrimitiveArray::from_iter(xs).into_array()),
+            ("y", PrimitiveArray::from_iter(ys).into_array()),
+        ])?
+        .into_array();
+        let metadata = GeoMetadata {
+            crs: Some("EPSG:4326".to_string()),
+        };
+        let dtype = ExtDType::<Point>::try_new(metadata, storage.dtype().clone())?;
+        Ok(ExtensionArray::new(dtype.erased(), storage).into_array())
+    }
+
+    /// A constant `Point` column of length `len`, every row at `(x, y)`.
+    fn point_constant(
+        x: f64,
+        y: f64,
+        len: usize,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let single = point_column(vec![x], vec![y])?.execute_scalar(0, ctx)?;
+        Ok(ConstantArray::new(single, len).into_array())
+    }
+
+    /// Execute a `GeoDistance` array and read back its per-row `f64` distances.
+    fn distances(distance: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Vec<f64>> {
+        Ok(distance
+            .execute::<Canonical>(ctx)?
+            .into_primitive()
+            .as_slice::<f64>()
+            .to_vec())
+    }
+
+    /// The kernel computes straight-line distance (the 3–4–5 triangle).
+    #[test]
+    fn euclidean_distance_is_straight_line() {
+        assert_eq!(euclidean_distance(0.0, 0.0, 3.0, 4.0), 5.0);
+        assert_eq!(euclidean_distance(1.5, -1.5, 1.5, -1.5), 0.0);
+    }
+
+    /// `GeoDistance` returns the per-row distance between two point columns (here the second is a
+    /// constant query point).
+    #[test]
+    fn distance_over_points() -> VortexResult<()> {
+        let session = VortexSession::empty().with::<ArraySession>();
+        let mut ctx = session.create_execution_ctx();
+
+        let a = point_column(vec![0.0, 3.0, 0.0, 3.0], vec![0.0, 0.0, 4.0, 4.0])?;
+        let b = point_constant(0.0, 0.0, 4, &mut ctx)?;
+        let distance = GeoDistance::try_new_array(a, b)?.into_array();
+
+        assert_eq!(distances(distance, &mut ctx)?, vec![0.0, 3.0, 4.0, 5.0]);
+        Ok(())
+    }
+
+    /// Column-to-column distance pairs corresponding rows of the two columns.
+    #[test]
+    fn distance_between_columns() -> VortexResult<()> {
+        let session = VortexSession::empty().with::<ArraySession>();
+        let mut ctx = session.create_execution_ctx();
+
+        let a = point_column(vec![0.0, 1.0], vec![0.0, 1.0])?;
+        let b = point_column(vec![3.0, 1.0], vec![4.0, 1.0])?;
+        let distance = GeoDistance::try_new_array(a, b)?.into_array();
+
+        assert_eq!(distances(distance, &mut ctx)?, vec![5.0, 0.0]);
+        Ok(())
+    }
+
+    /// The constant query point may be either operand; distance is symmetric.
+    #[test]
+    fn distance_with_constant_first_operand() -> VortexResult<()> {
+        let session = VortexSession::empty().with::<ArraySession>();
+        let mut ctx = session.create_execution_ctx();
+
+        let a = point_constant(0.0, 0.0, 4, &mut ctx)?;
+        let b = point_column(vec![0.0, 3.0, 0.0, 3.0], vec![0.0, 0.0, 4.0, 4.0])?;
+        let distance = GeoDistance::try_new_array(a, b)?.into_array();
+
+        assert_eq!(distances(distance, &mut ctx)?, vec![0.0, 3.0, 4.0, 5.0]);
+        Ok(())
+    }
+
+    /// Two constant operands: every row has the same distance.
+    #[test]
+    fn distance_between_two_constants() -> VortexResult<()> {
+        let session = VortexSession::empty().with::<ArraySession>();
+        let mut ctx = session.create_execution_ctx();
+
+        let a = point_constant(0.0, 0.0, 3, &mut ctx)?;
+        let b = point_constant(3.0, 4.0, 3, &mut ctx)?;
+        let distance = GeoDistance::try_new_array(a, b)?.into_array();
+
+        assert_eq!(distances(distance, &mut ctx)?, vec![5.0, 5.0, 5.0]);
+        Ok(())
+    }
+}
diff --git a/vortex-turboquant/src/sorf/mod.rs b/vortex-geo/src/scalar_fn/mod.rs
similarity index 51%
rename from vortex-turboquant/src/sorf/mod.rs
rename to vortex-geo/src/scalar_fn/mod.rs
index cce477aa906..385208f1991 100644
--- a/vortex-turboquant/src/sorf/mod.rs
+++ b/vortex-geo/src/scalar_fn/mod.rs
@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-mod splitmix64;
-mod transform;
+//! Geometry scalar functions over the [`Point`](crate::extension::Point) type.
 
-pub(crate) use transform::SorfMatrix;
+pub mod distance;
diff --git a/vortex-io/src/compat/filesystem.rs b/vortex-io/src/compat/filesystem.rs
index 9f9902b6a08..440ecfe8a71 100644
--- a/vortex-io/src/compat/filesystem.rs
+++ b/vortex-io/src/compat/filesystem.rs
@@ -21,6 +21,10 @@ impl<F: FileSystem> FileSystem for Compat<F> {
         Compat::new(self.inner().list(prefix)).boxed()
     }
 
+    async fn head(&self, path: &str) -> VortexResult<Option<FileListing>> {
+        Compat::new(self.inner().head(path)).await
+    }
+
     async fn open_read(&self, path: &str) -> VortexResult<Arc<dyn VortexReadAt>> {
         let read_at = Compat::new(self.inner().open_read(path)).await?;
         Ok(Arc::new(Compat::new(read_at)))
diff --git a/vortex-io/src/filesystem/glob.rs b/vortex-io/src/filesystem/glob.rs
index 6bbe26fa5dc..030bf4f56d1 100644
--- a/vortex-io/src/filesystem/glob.rs
+++ b/vortex-io/src/filesystem/glob.rs
@@ -3,6 +3,7 @@
 
 use futures::StreamExt;
 use futures::TryStreamExt;
+use futures::stream;
 use futures::stream::BoxStream;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
@@ -22,14 +23,18 @@ impl dyn FileSystem + '_ {
     pub fn glob(&self, pattern: &str) -> VortexResult<BoxStream<'_, VortexResult<FileListing>>> {
         validate_glob(pattern)?;
 
-        // If there are no glob characters, the pattern is an exact file path.
-        // Return it directly without listing the filesystem.
+        // If there are no glob characters, the pattern is an exact file path. `list` enumerates
+        // entries *under* a prefix on a path-segment basis and never yields the prefix itself, so
+        // listing an exact path would report an existing file as missing (and could surface prefix
+        // collisions such as `foo.vortex.backup` when the caller asked for `foo.vortex`). Use
+        // `head` to confirm the file exists and capture its size, yielding a single-element stream
+        // when it does and an empty stream when it does not.
         if !pattern.contains(['*', '?', '[']) {
-            let listing = FileListing {
-                path: pattern.to_string(),
-                size: None,
-            };
-            return Ok(futures::stream::once(async { Ok(listing) }).boxed());
+            let pattern = pattern.to_string();
+            let stream = stream::once(async move { self.head(&pattern).await })
+                .try_filter_map(|listing| async move { Ok(listing) })
+                .boxed();
+            return Ok(stream);
         }
 
         let glob_pattern = glob::Pattern::new(pattern)
@@ -93,14 +98,41 @@ mod tests {
     use crate::VortexReadAt;
     use crate::filesystem::FileSystem;
 
-    /// A mock filesystem that panics if `list` is called.
+    /// A mock filesystem that resolves exact paths through [`head`](FileSystem::head) and
+    /// panics if [`list`](FileSystem::list) is called. This encodes the invariant the fix
+    /// depends on: the exact-path glob branch must never list, because an object store's `list`
+    /// does not return the exact path of a file.
     #[derive(Debug)]
-    struct NoListFileSystem;
+    struct HeadFileSystem {
+        files: Vec<FileListing>,
+    }
+
+    impl HeadFileSystem {
+        fn new(files: &[(&str, u64)]) -> Self {
+            Self {
+                files: files
+                    .iter()
+                    .map(|&(path, size)| FileListing {
+                        path: path.to_string(),
+                        size: Some(size),
+                    })
+                    .collect(),
+            }
+        }
+    }
 
     #[async_trait]
-    impl FileSystem for NoListFileSystem {
+    impl FileSystem for HeadFileSystem {
         fn list(&self, _prefix: &str) -> BoxStream<'_, VortexResult<FileListing>> {
-            vortex_panic!("list() should not be called for exact paths")
+            vortex_panic!("list() must not be called for an exact path; glob should use head()")
+        }
+
+        async fn head(&self, path: &str) -> VortexResult<Option<FileListing>> {
+            Ok(self
+                .files
+                .iter()
+                .find(|listing| listing.path == path)
+                .cloned())
         }
 
         async fn open_read(&self, _path: &str) -> VortexResult<Arc<dyn VortexReadAt>> {
@@ -113,12 +145,43 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_glob_exact_path_skips_list() -> VortexResult<()> {
-        let fs: &dyn FileSystem = &NoListFileSystem;
-        let results: Vec<FileListing> = fs.glob("data/file.vortex")?.try_collect().await?;
+    async fn test_glob_exact_path_existing_returns_listing_with_size() -> VortexResult<()> {
+        let fs = HeadFileSystem::new(&[("data/file.vortex", 1024)]);
+        let fs_dyn: &dyn FileSystem = &fs;
+        let results: Vec<FileListing> = fs_dyn.glob("data/file.vortex")?.try_collect().await?;
         assert_eq!(results.len(), 1);
         assert_eq!(results[0].path, "data/file.vortex");
-        assert_eq!(results[0].size, None);
+        assert_eq!(
+            results[0].size,
+            Some(1024),
+            "exact-path glob should propagate the size reported by head"
+        );
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_glob_exact_path_missing_returns_empty_stream() -> VortexResult<()> {
+        let fs = HeadFileSystem::new(&[]);
+        let fs_dyn: &dyn FileSystem = &fs;
+        let results: Vec<FileListing> = fs_dyn.glob("data/missing.vortex")?.try_collect().await?;
+        assert!(
+            results.is_empty(),
+            "missing exact path should yield an empty stream"
+        );
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_glob_exact_path_ignores_prefix_siblings() -> VortexResult<()> {
+        // A real object store lists by prefix and would surface `foo.vortex.backup` when asked to
+        // list `foo.vortex`. Resolving the exact path via head sidesteps that: only the requested
+        // key is returned, and the panicking `list` proves the branch never enumerated.
+        let fs = HeadFileSystem::new(&[("foo.vortex", 10), ("foo.vortex.backup", 20)]);
+        let fs_dyn: &dyn FileSystem = &fs;
+        let results: Vec<FileListing> = fs_dyn.glob("foo.vortex")?.try_collect().await?;
+        assert_eq!(results.len(), 1);
+        assert_eq!(results[0].path, "foo.vortex");
+        assert_eq!(results[0].size, Some(10));
         Ok(())
     }
 
diff --git a/vortex-io/src/filesystem/mod.rs b/vortex-io/src/filesystem/mod.rs
index 97535909d28..d21a1bd8200 100644
--- a/vortex-io/src/filesystem/mod.rs
+++ b/vortex-io/src/filesystem/mod.rs
@@ -36,6 +36,16 @@ pub type FileSystemRef = Arc<dyn FileSystem>;
 /// Implementations handle the details of a particular storage backend (local disk, S3, GCS, etc.)
 /// while consumers work through this uniform interface.
 ///
+/// # Paths
+///
+/// Path strings are *literal* object keys / file paths: the characters are used verbatim, with no
+/// shell-style `~` expansion (`~` is a literal tilde, not the home directory) and no
+/// percent-encoding or -decoding applied by this layer (`%20` is the three characters `%`, `2`,
+/// `0`, not a space). A path produced by [`list`](FileSystem::list) or [`head`](FileSystem::head)
+/// is the object's actual key, so it can be passed straight back to
+/// [`open_read`](FileSystem::open_read) — including when it contains characters such as `~`, `%`,
+/// `[`, `]`, or `#`.
+///
 /// # Future Work
 ///
 /// An `open_write` method will be added once [`VortexWrite`](crate::VortexWrite) is
@@ -51,6 +61,17 @@ pub trait FileSystem: Debug + Send + Sync {
     /// callers should sort if deterministic ordering is required.
     fn list(&self, prefix: &str) -> BoxStream<'_, VortexResult<FileListing>>;
 
+    /// Fetch metadata for the file at the exact `path`, if it exists.
+    ///
+    /// Unlike [`list`](FileSystem::list), which enumerates files *under* a prefix on a
+    /// path-segment basis and never yields the prefix itself, `head` looks up the object at
+    /// exactly `path`. It is the correct primitive for confirming that a single known file
+    /// exists and reading its size.
+    ///
+    /// Returns `Ok(Some(_))` with the file's [`FileListing`] when it exists, `Ok(None)` when no
+    /// file exists at `path`, and `Err(_)` for any other failure (I/O or permission errors, etc.).
+    async fn head(&self, path: &str) -> VortexResult<Option<FileListing>>;
+
     /// Open a file for reading at the given path.
     async fn open_read(&self, path: &str) -> VortexResult<Arc<dyn VortexReadAt>>;
 
diff --git a/vortex-io/src/filesystem/prefix.rs b/vortex-io/src/filesystem/prefix.rs
index 5f6304430aa..d96f54cd9bb 100644
--- a/vortex-io/src/filesystem/prefix.rs
+++ b/vortex-io/src/filesystem/prefix.rs
@@ -52,6 +52,18 @@ impl FileSystem for PrefixFileSystem {
             .boxed()
     }
 
+    async fn head(&self, path: &str) -> VortexResult<Option<FileListing>> {
+        let full_path = format!("{}{}", self.prefix, path.trim_start_matches('/'));
+        Ok(self.inner.head(&full_path).await?.map(|mut listing| {
+            listing.path = listing
+                .path
+                .strip_prefix(&self.prefix)
+                .unwrap_or(&listing.path)
+                .to_string();
+            listing
+        }))
+    }
+
     async fn open_read(&self, path: &str) -> VortexResult<Arc<dyn VortexReadAt>> {
         self.inner
             .open_read(&format!("{}{}", self.prefix, path.trim_start_matches('/')))
diff --git a/vortex-io/src/object_store/filesystem.rs b/vortex-io/src/object_store/filesystem.rs
index b8c2aa39ce2..0688216fc0f 100644
--- a/vortex-io/src/object_store/filesystem.rs
+++ b/vortex-io/src/object_store/filesystem.rs
@@ -55,31 +55,60 @@ impl ObjectStoreFileSystem {
     }
 }
 
+/// Convert a literal filesystem path into an object-store [`Path`] (key).
+///
+/// Object stores key their objects *literally*: a file named `a~b.vortex` has the key
+/// `a~b.vortex`, and `LocalFileSystem` likewise surfaces real filenames verbatim. [`Path::parse`]
+/// preserves those characters, whereas [`Path::from`] percent-encodes `~`, `%`, `[`, `]`, `#`,
+/// etc. — turning `a~b.vortex` into the key `a%7Eb.vortex`, which no real object has. Using
+/// `parse` keeps inputs and the keys returned by [`list`](FileSystem::list) on the same literal
+/// representation, so a path from `list`/`head` round-trips back through `open_read` unchanged.
+///
+/// `parse` rejects empty, `.`, and `..` segments; for those we fall back to [`Path::from`], which
+/// normalizes them (this never applies to a key `list` produced, so it cannot break a round-trip).
+fn to_object_path(path: &str) -> Path {
+    Path::parse(path).unwrap_or_else(|_| Path::from(path))
+}
+
+fn listing_from_meta(location: &Path, size: u64) -> FileListing {
+    FileListing {
+        path: location.to_string(),
+        size: Some(size),
+    }
+}
+
 #[async_trait]
 impl FileSystem for ObjectStoreFileSystem {
     fn list(&self, prefix: &str) -> BoxStream<'_, VortexResult<FileListing>> {
         let path = if prefix.is_empty() {
             None
         } else {
-            Some(Path::from(prefix))
+            Some(to_object_path(prefix))
         };
         self.store
             .list(path.as_ref())
             .map(|result| {
                 result
-                    .map(|meta| FileListing {
-                        path: meta.location.to_string(),
-                        size: Some(meta.size),
-                    })
+                    .map(|meta| listing_from_meta(&meta.location, meta.size))
                     .map_err(Into::into)
             })
             .boxed()
     }
 
+    async fn head(&self, path: &str) -> VortexResult<Option<FileListing>> {
+        // `head` issues a single metadata lookup (e.g. an S3 HEAD) for the exact key, unlike
+        // `list`, which enumerates by path-segment prefix and never returns the key itself.
+        match self.store.head(&to_object_path(path)).await {
+            Ok(meta) => Ok(Some(listing_from_meta(&meta.location, meta.size))),
+            Err(object_store::Error::NotFound { .. }) => Ok(None),
+            Err(e) => Err(e.into()),
+        }
+    }
+
     async fn open_read(&self, path: &str) -> VortexResult<Arc<dyn VortexReadAt>> {
         Ok(Arc::new(ObjectStoreReadAt::new(
             Arc::clone(&self.store),
-            path.into(),
+            to_object_path(path),
             self.handle.clone(),
         )))
     }
@@ -94,3 +123,174 @@ impl FileSystem for ObjectStoreFileSystem {
         Ok(())
     }
 }
+
+// Exercises the fix against a real object store, whose `list` excludes the exact-path match.
+// `Handle::find` only resolves a runtime under the `tokio` feature, so gate these tests on it.
+#[cfg(test)]
+#[cfg(feature = "tokio")]
+mod tests {
+    use futures::TryStreamExt;
+    use object_store::ObjectStoreExt;
+    use object_store::local::LocalFileSystem;
+    use object_store::memory::InMemory;
+    use rstest::rstest;
+
+    use super::*;
+    use crate::filesystem::FileSystem;
+    use crate::runtime::Handle;
+
+    /// Build an [`ObjectStoreFileSystem`] over an in-memory store seeded with `(path, size)` files.
+    ///
+    /// Keys are written with [`to_object_path`] so the store holds the same literal keys a real
+    /// backend would (e.g. `a~b.vortex`, not the percent-encoded `a%7Eb.vortex`).
+    async fn memory_fs(files: &[(&str, usize)]) -> VortexResult<ObjectStoreFileSystem> {
+        let store = Arc::new(InMemory::new()) as Arc<dyn ObjectStore>;
+        for &(path, size) in files {
+            store
+                .put(&to_object_path(path), vec![0u8; size].into())
+                .await?;
+        }
+        let handle = Handle::find().expect("tokio runtime available within #[tokio::test]");
+        Ok(ObjectStoreFileSystem::new(store, handle))
+    }
+
+    /// Regression test for #6599: globbing an exact path that exists must return that one file.
+    /// `ObjectStore::list` never yields the prefix itself, so this would return nothing if the
+    /// exact-path branch used `list`.
+    #[tokio::test]
+    async fn test_glob_exact_existing_path() -> VortexResult<()> {
+        let fs = memory_fs(&[("data/file.vortex", 1024)]).await?;
+        let fs_dyn: &dyn FileSystem = &fs;
+        let results: Vec<FileListing> = fs_dyn.glob("data/file.vortex")?.try_collect().await?;
+        assert_eq!(results.len(), 1);
+        assert_eq!(results[0].path, "data/file.vortex");
+        assert_eq!(results[0].size, Some(1024));
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_glob_exact_missing_path_is_empty() -> VortexResult<()> {
+        let fs = memory_fs(&[("data/other.vortex", 1)]).await?;
+        let fs_dyn: &dyn FileSystem = &fs;
+        let results: Vec<FileListing> = fs_dyn.glob("data/missing.vortex")?.try_collect().await?;
+        assert!(results.is_empty());
+        Ok(())
+    }
+
+    /// `list("foo.vortex")` would surface the prefix-sibling `foo.vortex.backup`; `head` does not.
+    #[tokio::test]
+    async fn test_glob_exact_path_ignores_prefix_siblings() -> VortexResult<()> {
+        let fs = memory_fs(&[("foo.vortex", 10), ("foo.vortex.backup", 20)]).await?;
+        let fs_dyn: &dyn FileSystem = &fs;
+        let results: Vec<FileListing> = fs_dyn.glob("foo.vortex")?.try_collect().await?;
+        assert_eq!(results.len(), 1);
+        assert_eq!(results[0].path, "foo.vortex");
+        assert_eq!(results[0].size, Some(10));
+        Ok(())
+    }
+
+    /// Paths containing characters that `object_store` percent-encodes (`~ % [ ] # { } ^`, …)
+    /// must round-trip on a single literal-path convention: `head` returns the literal key, and
+    /// that exact string must reopen the file via `open_read` (what multi-file scan does).
+    /// Previously these were converted with `Path::from`, which encoded them into a key no real
+    /// object has, so the file was silently lost.
+    #[tokio::test]
+    #[rstest]
+    #[case::tilde("dir/a~b.vortex")]
+    #[case::percent("dir/a%20b.vortex")]
+    #[case::brackets("dir/a[1].vortex")]
+    #[case::hash("dir/a#b.vortex")]
+    #[case::braces("dir/a{x}.vortex")]
+    #[case::caret("dir/a^b.vortex")]
+    #[case::backslash_tilde("dir/a\\~b.vortex")]
+    #[case::space("dir/a b.vortex")]
+    async fn test_head_open_read_round_trip_special_chars(#[case] path: &str) -> VortexResult<()> {
+        let fs = memory_fs(&[(path, 5)]).await?;
+        // `head` returns the literal key, matching the caller's input.
+        assert_eq!(
+            fs.head(path).await?,
+            Some(FileListing {
+                path: path.to_string(),
+                size: Some(5),
+            })
+        );
+        // and that literal path reopens the file (`size()` issues a `head` under the hood).
+        assert_eq!(fs.open_read(path).await?.size().await?, 5);
+        Ok(())
+    }
+
+    /// Glob (both branches) over paths with encoded—but not glob-metacharacter—characters returns
+    /// the literal path, which must reopen the file. (`*`, `?`, `[` are excluded here: they make
+    /// the input a pattern rather than an exact path.)
+    #[tokio::test]
+    #[rstest]
+    #[case::tilde("dir/a~b.vortex")]
+    #[case::percent("dir/a%20b.vortex")]
+    #[case::hash("dir/a#b.vortex")]
+    #[case::backslash_tilde("dir/a\\~b.vortex")]
+    #[case::space("dir/a b.vortex")]
+    #[case::plain("dir/plain.vortex")]
+    async fn test_glob_round_trip_special_chars(#[case] path: &str) -> VortexResult<()> {
+        let fs = memory_fs(&[(path, 5)]).await?;
+        let fs_dyn: &dyn FileSystem = &fs;
+        let expected = FileListing {
+            path: path.to_string(),
+            size: Some(5),
+        };
+
+        // Exact-path glob returns the literal path.
+        let exact: Vec<FileListing> = fs_dyn.glob(path)?.try_collect().await?;
+        assert_eq!(exact, vec![expected.clone()]);
+
+        // Wildcard glob over the directory lists the same literal path (not an encoded one).
+        let wild: Vec<FileListing> = fs_dyn.glob("dir/*.vortex")?.try_collect().await?;
+        assert!(
+            wild.contains(&expected),
+            "wildcard glob should list {path:?}, got {wild:?}"
+        );
+
+        // The returned path reopens the file.
+        assert_eq!(fs.open_read(path).await?.size().await?, 5);
+        Ok(())
+    }
+
+    /// The same round-trip against the real local-filesystem backend: a `~` in an on-disk filename
+    /// must be addressed literally (converting it with `Path::from` would percent-encode it and
+    /// miss the file). Confirms the literal-path convention holds across backends, not just for the
+    /// in-memory store.
+    #[tokio::test]
+    async fn test_local_filesystem_special_char_round_trip() -> anyhow::Result<()> {
+        let dir = tempfile::tempdir()?;
+        std::fs::write(dir.path().join("a~b.vortex"), [0u8; 5])?;
+        let store = Arc::new(LocalFileSystem::new_with_prefix(dir.path())?) as Arc<dyn ObjectStore>;
+        let fs = ObjectStoreFileSystem::new(store, Handle::find().expect("tokio runtime"));
+        let fs_dyn: &dyn FileSystem = &fs;
+        let expected = FileListing {
+            path: "a~b.vortex".to_string(),
+            size: Some(5),
+        };
+
+        let wild: Vec<FileListing> = fs_dyn.glob("*.vortex")?.try_collect().await?;
+        assert!(wild.contains(&expected), "wildcard glob got {wild:?}");
+
+        let exact: Vec<FileListing> = fs_dyn.glob("a~b.vortex")?.try_collect().await?;
+        assert_eq!(exact, vec![expected]);
+
+        assert_eq!(fs.open_read("a~b.vortex").await?.size().await?, 5);
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_head_existing_and_missing() -> VortexResult<()> {
+        let fs = memory_fs(&[("a/b.vortex", 7)]).await?;
+        assert_eq!(
+            fs.head("a/b.vortex").await?,
+            Some(FileListing {
+                path: "a/b.vortex".to_string(),
+                size: Some(7),
+            })
+        );
+        assert_eq!(fs.head("a/missing.vortex").await?, None);
+        Ok(())
+    }
+}
diff --git a/vortex-io/src/runtime/handle.rs b/vortex-io/src/runtime/handle.rs
index 3fc3203fae1..8675f051f19 100644
--- a/vortex-io/src/runtime/handle.rs
+++ b/vortex-io/src/runtime/handle.rs
@@ -68,7 +68,13 @@ impl Handle {
         R: Send + 'static,
     {
         let (send, recv) = oneshot::channel();
-        let span = tracing::Span::current();
+        // Instrument with a dedicated, named span on its own target rather than
+        // re-entering `Span::current()`. `Instrumented::poll` enters and exits the
+        // span on every poll, so re-entering the caller's span makes its cost scale
+        // with poll count. A distinct target lets subscribers opt these spans in or
+        // out via filtering; when filtered out the span is disabled and enter/exit
+        // are no-ops, which keeps frequently-polled spawned futures cheap.
+        let span = tracing::trace_span!(target: "vortex_io::spawn", "spawn");
         let abort_handle = self.runtime().spawn(
             async move {
                 // Task::detach allows the receiver to be dropped, so we ignore send errors.
@@ -104,7 +110,11 @@ impl Handle {
         R: Send + 'static,
     {
         let (send, recv) = oneshot::channel();
-        let span = tracing::Span::current();
+        // See `spawn` above: a dedicated target rather than `Span::current()` so
+        // subscribers can filter these spans in or out. I/O futures are polled
+        // frequently, so disabling the span (the default for an unconfigured
+        // target) avoids per-poll enter/exit cost.
+        let span = tracing::trace_span!(target: "vortex_io::spawn_io", "spawn_io");
         let abort_handle = self.runtime().spawn_io(
             async move {
                 // Task::detach allows the receiver to be dropped, so we ignore send errors.
diff --git a/vortex-jni/Cargo.toml b/vortex-jni/Cargo.toml
index 628c2c89d43..d5f5cea61aa 100644
--- a/vortex-jni/Cargo.toml
+++ b/vortex-jni/Cargo.toml
@@ -24,11 +24,13 @@ futures = { workspace = true }
 jni = { workspace = true }
 object_store = { workspace = true, features = ["aws", "azure", "gcp"] }
 parking_lot = { workspace = true }
+roaring = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true, features = ["std", "log"] }
 tracing-subscriber = { workspace = true, features = ["env-filter"] }
 url = { workspace = true }
 vortex = { workspace = true, features = ["object_store", "files"] }
+vortex-parquet-variant = { workspace = true }
 
 [dev-dependencies]
 jni = { workspace = true, features = ["invocation"] }
diff --git a/vortex-jni/src/dtype.rs b/vortex-jni/src/dtype.rs
index f748135ade1..5a0b54d2c14 100644
--- a/vortex-jni/src/dtype.rs
+++ b/vortex-jni/src/dtype.rs
@@ -10,8 +10,8 @@ use arrow_array::ffi::FFI_ArrowSchema;
 use arrow_schema::DataType;
 use arrow_schema::FieldRef;
 use arrow_schema::Fields;
+use arrow_schema::Schema;
 use vortex::dtype::DType;
-use vortex::dtype::arrow::FromArrowType;
 use vortex::error::VortexResult;
 
 /// Export a Vortex [`DType`] to the Arrow C Data Interface struct at `schema_addr`. Views
@@ -24,7 +24,7 @@ pub(crate) fn export_dtype_to_arrow(dtype: &DType, schema_addr: i64) -> VortexRe
         DataType::Struct(fields) => fields,
         _ => unreachable!("Vortex DType always exports as a struct"),
     };
-    let schema = arrow_schema::Schema::new(fields);
+    let schema = Schema::new(fields);
     let ffi_schema = FFI_ArrowSchema::try_from(&schema)?;
     unsafe {
         ptr::write(schema_addr as *mut FFI_ArrowSchema, ffi_schema);
@@ -70,9 +70,8 @@ pub(crate) fn strip_views(data_type: DataType) -> DataType {
     }
 }
 
-/// Decode an [`FFI_ArrowSchema`] pointed to by `schema_addr` into a Vortex [`DType`].
-pub(crate) fn import_dtype_from_arrow(schema_addr: i64) -> VortexResult<DType> {
+/// Decode an [`FFI_ArrowSchema`] pointed to by `schema_addr` into an Arrow [`Schema`].
+pub(crate) fn import_arrow_schema(schema_addr: i64) -> VortexResult<Schema> {
     let ffi_schema = unsafe { &*(schema_addr as *const FFI_ArrowSchema) };
-    let arrow_schema = arrow_schema::Schema::try_from(ffi_schema)?;
-    Ok(DType::from_arrow(&arrow_schema))
+    Ok(Schema::try_from(ffi_schema)?)
 }
diff --git a/vortex-jni/src/expression.rs b/vortex-jni/src/expression.rs
index 035990b14db..77d709ddd38 100644
--- a/vortex-jni/src/expression.rs
+++ b/vortex-jni/src/expression.rs
@@ -39,8 +39,10 @@ use vortex::expr::get_item;
 use vortex::expr::is_not_null;
 use vortex::expr::is_null;
 use vortex::expr::lit;
+use vortex::expr::merge_opts;
 use vortex::expr::not;
 use vortex::expr::or_collect;
+use vortex::expr::pack;
 use vortex::expr::root;
 use vortex::expr::select;
 use vortex::extension::datetime::Date;
@@ -58,6 +60,7 @@ use vortex::scalar_fn::fns::between::StrictComparison;
 use vortex::scalar_fn::fns::binary::Binary;
 use vortex::scalar_fn::fns::like::Like;
 use vortex::scalar_fn::fns::like::LikeOptions;
+use vortex::scalar_fn::fns::merge::DuplicateHandling;
 use vortex::scalar_fn::fns::operators::Operator;
 
 use crate::errors::JNIError;
@@ -96,6 +99,17 @@ fn parse_time_unit(tag: jbyte) -> Result<TimeUnit, JNIError> {
     TimeUnit::try_from(tag as u8).map_err(JNIError::from)
 }
 
+/// Parse a merge [`DuplicateHandling`] strategy from its wire-encoded byte tag.
+///
+/// See `dev.vortex.api.Expression.DuplicateHandling` on the Java side for the source of truth.
+fn parse_duplicate_handling(tag: jbyte) -> Result<DuplicateHandling, JNIError> {
+    Ok(match tag {
+        0 => DuplicateHandling::RightMost,
+        1 => DuplicateHandling::Error,
+        other => throw_runtime!("unknown duplicate handling code: {other}"),
+    })
+}
+
 #[unsafe(no_mangle)]
 pub extern "system" fn Java_dev_vortex_jni_NativeExpression_free(
     _env: EnvUnowned,
@@ -161,6 +175,54 @@ pub extern "system" fn Java_dev_vortex_jni_NativeExpression_select(
     })
 }
 
+#[unsafe(no_mangle)]
+pub extern "system" fn Java_dev_vortex_jni_NativeExpression_pack(
+    mut env: EnvUnowned,
+    _class: JClass,
+    field_names: JObjectArray,
+    expressions: JLongArray,
+    nullable: jboolean,
+) -> jlong {
+    try_or_throw(&mut env, |env| {
+        let count = field_names.len(env)?;
+        let expressions = unsafe { expressions.get_elements(env, ReleaseMode::NoCopyBack)? };
+        let mut elements = Vec::with_capacity(count);
+
+        for idx in 0..count {
+            let obj = field_names.get_element(env, idx)?;
+            let s = env.cast_local::<JString>(obj)?;
+            let name: FieldName = s.try_to_string(env)?.into();
+
+            let expr_ptr = *expressions.get(idx).ok_or_else(|| -> JNIError {
+                vortex_err!("missing pack expression child").into()
+            })?;
+            let expr = unsafe { expr_ref(expr_ptr) }.clone();
+
+            elements.push((name, expr));
+        }
+
+        Ok(into_raw(pack(elements, nullable.into())))
+    })
+}
+
+/// Merge zero or more struct-returning expressions into a single struct.
+///
+/// `duplicate_handling` selects how shared field names are resolved (see
+/// [`parse_duplicate_handling`]). An empty `expressions` array yields an empty struct.
+#[unsafe(no_mangle)]
+pub extern "system" fn Java_dev_vortex_jni_NativeExpression_merge(
+    mut env: EnvUnowned,
+    _class: JClass,
+    expressions: JLongArray,
+    duplicate_handling: jbyte,
+) -> jlong {
+    try_or_throw(&mut env, |env| {
+        let exprs = collect_operands(env, &expressions)?;
+        let handling = parse_duplicate_handling(duplicate_handling)?;
+        Ok(into_raw(merge_opts(exprs, handling)))
+    })
+}
+
 #[unsafe(no_mangle)]
 pub extern "system" fn Java_dev_vortex_jni_NativeExpression_and(
     mut env: EnvUnowned,
diff --git a/vortex-jni/src/scan.rs b/vortex-jni/src/scan.rs
index 08dc18342eb..606ec8cd040 100644
--- a/vortex-jni/src/scan.rs
+++ b/vortex-jni/src/scan.rs
@@ -10,6 +10,7 @@
 //! 3. `Java_dev_vortex_jni_NativePartition_scanArrow` → consumes a partition into an
 //!    `FFI_ArrowArrayStream` that Java imports via Arrow's C Data Interface.
 
+use std::io::Cursor;
 use std::ops::Range;
 use std::ptr;
 use std::sync::Arc;
@@ -22,6 +23,7 @@ use arrow_schema::DataType;
 use arrow_schema::Field;
 use futures::StreamExt;
 use jni::EnvUnowned;
+use jni::objects::JByteArray;
 use jni::objects::JClass;
 use jni::objects::JLongArray;
 use jni::sys::jboolean;
@@ -75,6 +77,7 @@ fn build_scan_request(
     row_range_begin: jlong,
     row_range_end: jlong,
     selection_idx: &[u64],
+    selection_roaring_bitmap: &[u8],
     selection_include: u8,
     limit: jlong,
     ordered: jboolean,
@@ -95,6 +98,8 @@ fn build_scan_request(
         0 => Selection::All,
         1 => Selection::IncludeByIndex(Buffer::copy_from(selection_idx)),
         2 => Selection::ExcludeByIndex(Buffer::copy_from(selection_idx)),
+        3 => Selection::IncludeRoaring(deserialize_roaring_selection(selection_roaring_bitmap)?),
+        4 => Selection::ExcludeRoaring(deserialize_roaring_selection(selection_roaring_bitmap)?),
         other => vortex_bail!("unknown selection include code: {other}"),
     };
 
@@ -117,6 +122,14 @@ fn build_scan_request(
     })
 }
 
+fn deserialize_roaring_selection(bytes: &[u8]) -> VortexResult<roaring::RoaringTreemap> {
+    if bytes.is_empty() {
+        vortex_bail!("serialized roaring row selection must not be empty");
+    }
+    let cursor = Cursor::new(bytes);
+    Ok(roaring::RoaringTreemap::deserialize_from(cursor)?)
+}
+
 #[allow(clippy::too_many_arguments)]
 #[unsafe(no_mangle)]
 pub extern "system" fn Java_dev_vortex_jni_NativeScan_create(
@@ -128,6 +141,7 @@ pub extern "system" fn Java_dev_vortex_jni_NativeScan_create(
     row_range_begin: jlong,
     row_range_end: jlong,
     selection_indices: JLongArray,
+    selection_roaring_bitmap: JByteArray,
     selection_include: jni::sys::jbyte,
     limit: jlong,
     ordered: jboolean,
@@ -151,12 +165,19 @@ pub extern "system" fn Java_dev_vortex_jni_NativeScan_create(
             out
         };
 
+        let selection_roaring_bitmap: Vec<u8> = if selection_roaring_bitmap.is_null() {
+            Vec::new()
+        } else {
+            env.convert_byte_array(&selection_roaring_bitmap)?
+        };
+
         let request = build_scan_request(
             projection_ptr,
             filter_ptr,
             row_range_begin,
             row_range_end,
             &selection_idx,
+            &selection_roaring_bitmap,
             selection_include as u8,
             limit,
             ordered,
diff --git a/vortex-jni/src/session.rs b/vortex-jni/src/session.rs
index 9f75d24f564..9adaf544431 100644
--- a/vortex-jni/src/session.rs
+++ b/vortex-jni/src/session.rs
@@ -16,7 +16,9 @@ use crate::RUNTIME;
 /// Constructs a fresh [`VortexSession`] bound to the JNI-shared tokio runtime and returns
 /// an opaque pointer that Java must pass to [`Java_dev_vortex_jni_NativeSession_free`].
 pub(crate) fn new_session() -> Box<VortexSession> {
-    Box::new(VortexSession::default().with_handle(RUNTIME.handle()))
+    let session = VortexSession::default().with_handle(RUNTIME.handle());
+    vortex_parquet_variant::initialize(&session);
+    Box::new(session)
 }
 
 /// SAFETY: caller must pass a pointer previously returned by [`new_session`].
diff --git a/vortex-jni/src/writer.rs b/vortex-jni/src/writer.rs
index da30952d87b..95d3ae1c400 100644
--- a/vortex-jni/src/writer.rs
+++ b/vortex-jni/src/writer.rs
@@ -13,6 +13,7 @@ use arrow_array::RecordBatch;
 use arrow_array::StructArray;
 use arrow_array::ffi::FFI_ArrowArray;
 use arrow_array::ffi::FFI_ArrowSchema;
+use arrow_schema::SchemaRef;
 use async_fs::File;
 use futures::SinkExt;
 use futures::channel::mpsc;
@@ -28,12 +29,16 @@ use object_store::ObjectStore;
 use object_store::path::Path as ObjectStorePath;
 use url::Url;
 use vortex::array::ArrayRef;
-use vortex::array::arrow::FromArrowArray;
+use vortex::array::VTable;
+use vortex::array::arrow::ArrowSessionExt;
 use vortex::array::stream::ArrayStreamAdapter;
 use vortex::dtype::DType;
+use vortex::dtype::Field as DTypeField;
+use vortex::dtype::FieldPath;
 use vortex::error::VortexResult;
 use vortex::error::vortex_err;
 use vortex::file::WriteOptionsSessionExt;
+use vortex::file::WriteStrategyBuilder;
 use vortex::file::WriteSummary;
 use vortex::io::VortexWrite;
 use vortex::io::compat::Compat;
@@ -41,10 +46,12 @@ use vortex::io::object_store::ObjectStoreWrite;
 use vortex::io::runtime::BlockingRuntime;
 use vortex::io::runtime::Task;
 use vortex::io::session::RuntimeSessionExt;
+use vortex::session::VortexSession;
 use vortex::utils::aliases::hash_map::HashMap;
+use vortex_parquet_variant::ParquetVariant;
 
 use crate::RUNTIME;
-use crate::dtype::import_dtype_from_arrow;
+use crate::dtype::import_arrow_schema;
 use crate::errors::JNIError;
 use crate::errors::try_or_throw;
 use crate::file::extract_properties;
@@ -81,21 +88,66 @@ fn resolve_store(
     }
 }
 
+fn write_options_for_schema(
+    session: &VortexSession,
+    write_schema: &DType,
+) -> vortex::file::VortexWriteOptions {
+    let variant_paths = variant_field_paths(write_schema);
+    if variant_paths.is_empty() {
+        return session.write_options();
+    }
+
+    let mut allowed = vortex::file::ALLOWED_ENCODINGS.clone();
+    allowed.insert(ParquetVariant.id());
+
+    let strategy = WriteStrategyBuilder::default().with_allow_encodings(allowed);
+
+    session.write_options().with_strategy(strategy.build())
+}
+
+fn variant_field_paths(dtype: &DType) -> Vec<FieldPath> {
+    let mut paths = Vec::new();
+    collect_variant_field_paths(dtype, FieldPath::root(), &mut paths);
+    paths
+}
+
+fn collect_variant_field_paths(dtype: &DType, path: FieldPath, paths: &mut Vec<FieldPath>) {
+    match dtype {
+        DType::Variant(_) => paths.push(path),
+        DType::Struct(fields, _) => {
+            for (name, field_dtype) in fields.names().iter().zip(fields.fields()) {
+                collect_variant_field_paths(
+                    &field_dtype,
+                    path.clone().push(DTypeField::from(name.clone())),
+                    paths,
+                );
+            }
+        }
+        _ => {}
+    }
+}
+
 /// Native writer holding a write-task handle and a sender that Java pushes batches into.
 pub struct NativeWriter {
     handle: Option<Task<VortexResult<WriteSummary>>>,
+    session: VortexSession,
+    arrow_schema: SchemaRef,
     write_schema: DType,
     sender: mpsc::Sender<VortexResult<ArrayRef>>,
 }
 
 impl NativeWriter {
     pub fn new(
+        session: VortexSession,
+        arrow_schema: SchemaRef,
         write_schema: DType,
         handle: Task<VortexResult<WriteSummary>>,
         sender: mpsc::Sender<VortexResult<ArrayRef>>,
     ) -> Self {
         Self {
             handle: Some(handle),
+            session,
+            arrow_schema,
             write_schema,
             sender,
         }
@@ -117,7 +169,10 @@ impl NativeWriter {
     }
 
     fn write_record_batch(&self, batch: RecordBatch) -> VortexResult<()> {
-        let vortex_batch = ArrayRef::from_arrow(batch, false)?;
+        let vortex_batch = self
+            .session
+            .arrow()
+            .from_arrow_record_batch(batch, self.arrow_schema.as_ref())?;
         if !vortex_batch.dtype().eq(&self.write_schema) {
             return Err(vortex_err!(
                 "write schema mismatch: expected {}, got {}",
@@ -162,13 +217,15 @@ pub extern "system" fn Java_dev_vortex_jni_NativeWriter_create(
         }
         let session = unsafe { session_ref(session_ptr) };
 
-        let write_schema = import_dtype_from_arrow(arrow_schema_addr)?;
+        let arrow_schema = Arc::new(import_arrow_schema(arrow_schema_addr)?);
+        let write_schema = session.arrow().from_arrow_schema(arrow_schema.as_ref())?;
 
         let file_path: String = uri.try_to_string(env)?;
         let properties: HashMap<String, String> = extract_properties(env, &options)?;
         let resolved = resolve_store(&file_path, &properties)?;
         let (tx, rx) = mpsc::channel(WRITE_CHANNEL_CAPACITY);
         let stream = ArrayStreamAdapter::new(write_schema.clone(), rx);
+        let write_options = write_options_for_schema(session, &write_schema);
 
         let handle = session.handle().spawn(async move {
             match resolved {
@@ -177,21 +234,28 @@ pub extern "system" fn Java_dev_vortex_jni_NativeWriter_create(
                         async_fs::create_dir_all(parent).await?;
                     }
                     let mut file = File::create(path).await?;
-                    let summary = session.write_options().write(&mut file, stream).await?;
+                    let summary = write_options.write(&mut file, stream).await?;
                     file.shutdown().await?;
                     Ok(summary)
                 }
                 ResolvedStore::ObjectStore(store, path) => {
                     let mut write =
                         ObjectStoreWrite::new(Arc::new(Compat::new(store)), &path).await?;
-                    let summary = session.write_options().write(&mut write, stream).await?;
+                    let summary = write_options.write(&mut write, stream).await?;
                     write.shutdown().await?;
                     Ok(summary)
                 }
             }
         });
 
-        Ok(Box::new(NativeWriter::new(write_schema, handle, tx)).into_raw())
+        Ok(Box::new(NativeWriter::new(
+            session.clone(),
+            arrow_schema,
+            write_schema,
+            handle,
+            tx,
+        ))
+        .into_raw())
     })
 }
 
diff --git a/vortex-json/Cargo.toml b/vortex-json/Cargo.toml
new file mode 100644
index 00000000000..4afd224f6aa
--- /dev/null
+++ b/vortex-json/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "vortex-json"
+authors = { workspace = true }
+categories = { workspace = true }
+description = "Vortex JSON extension type"
+edition = { workspace = true }
+homepage = { workspace = true }
+include = { workspace = true }
+keywords = { workspace = true }
+license = { workspace = true }
+readme = { workspace = true }
+repository = { workspace = true }
+rust-version = { workspace = true }
+version = { workspace = true }
+
+[lints]
+workspace = true
+
+[dependencies]
+arrow-array = { workspace = true }
+arrow-schema = { workspace = true, features = ["canonical_extension_types"] }
+vortex-array = { workspace = true, default-features = false }
+vortex-error = { workspace = true, default-features = false }
+vortex-session = { workspace = true }
diff --git a/vortex-json/src/arrow.rs b/vortex-json/src/arrow.rs
new file mode 100644
index 00000000000..499a4144131
--- /dev/null
+++ b/vortex-json/src/arrow.rs
@@ -0,0 +1,234 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Arrow import and export support for the JSON extension dtype.
+
+use arrow_array::ArrayRef as ArrowArrayRef;
+use arrow_schema::Field;
+use arrow_schema::extension::ExtensionType;
+use arrow_schema::extension::Json as ArrowJson;
+use vortex_array::ArrayRef;
+use vortex_array::EmptyMetadata;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
+use vortex_array::arrays::ExtensionArray;
+use vortex_array::arrays::extension::ExtensionArrayExt;
+use vortex_array::arrow::ArrowExport;
+use vortex_array::arrow::ArrowExportVTable;
+use vortex_array::arrow::ArrowImport;
+use vortex_array::arrow::ArrowImportVTable;
+use vortex_array::arrow::ArrowSession;
+use vortex_array::arrow::ArrowSessionExt;
+use vortex_array::arrow::FromArrowArray;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::extension::ExtDType;
+use vortex_array::dtype::extension::ExtVTable;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_session::registry::CachedId;
+use vortex_session::registry::Id;
+
+use crate::Json;
+
+/// Arrow's canonical JSON extension name cached as a registry id.
+static ARROW_JSON: CachedId = CachedId::new(ArrowJson::NAME);
+
+/// Returns whether an Arrow field contains valid canonical JSON extension metadata.
+fn has_valid_json_extension(field: &Field) -> bool {
+    field.extension_type_name() == Some(ArrowJson::NAME)
+        && ArrowJson::try_new_from_field_metadata(field.data_type(), field.metadata()).is_ok()
+}
+
+impl ArrowExportVTable for Json {
+    fn arrow_ext_id(&self) -> Id {
+        *ARROW_JSON
+    }
+
+    fn vortex_id(&self) -> Id {
+        Json.id()
+    }
+
+    fn to_arrow_field(
+        &self,
+        name: &str,
+        dtype: &DType,
+        session: &ArrowSession,
+    ) -> VortexResult<Option<Field>> {
+        let DType::Extension(ext_dtype) = dtype else {
+            return Ok(None);
+        };
+        if !ext_dtype.is::<Json>() {
+            return Ok(None);
+        }
+
+        let mut field = session.to_arrow_field(name, ext_dtype.storage_dtype())?;
+        field
+            .try_with_extension_type(ArrowJson::default())
+            .vortex_expect("Utf8 is a valid storage type for Arrow JSON");
+        Ok(Some(field))
+    }
+
+    fn execute_arrow(
+        &self,
+        array: ArrayRef,
+        target: &Field,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrowExport> {
+        let is_json = array
+            .dtype()
+            .as_extension_opt()
+            .map(|ext_dtype| ext_dtype.is::<Json>())
+            .unwrap_or(false);
+        if !is_json {
+            return Ok(ArrowExport::Unsupported(array));
+        }
+
+        ArrowJson::try_new_from_field_metadata(target.data_type(), target.metadata())?;
+
+        let executed = array.execute::<ExtensionArray>(ctx)?;
+        let storage = executed.storage_array().clone();
+        let storage_field = Field::new(
+            String::new(),
+            target.data_type().clone(),
+            target.is_nullable(),
+        );
+        let session = ctx.session().clone();
+
+        let storage = session
+            .arrow()
+            .execute_arrow(storage, Some(&storage_field), ctx)?;
+
+        Ok(ArrowExport::Exported(storage))
+    }
+}
+
+impl ArrowImportVTable for Json {
+    fn arrow_ext_id(&self) -> Id {
+        *ARROW_JSON
+    }
+
+    fn from_arrow_field(&self, field: &Field) -> VortexResult<Option<DType>> {
+        if !has_valid_json_extension(field) {
+            return Ok(None);
+        }
+
+        Ok(Some(DType::Extension(
+            ExtDType::<Json>::try_new(EmptyMetadata, DType::Utf8(field.is_nullable().into()))?
+                .erased(),
+        )))
+    }
+
+    fn from_arrow_array(
+        &self,
+        array: ArrowArrayRef,
+        field: &Field,
+        dtype: &DType,
+    ) -> VortexResult<ArrowImport> {
+        let DType::Extension(ext_dtype) = dtype else {
+            return Ok(ArrowImport::Unsupported(array));
+        };
+        if !ext_dtype.is::<Json>() || !has_valid_json_extension(field) {
+            return Ok(ArrowImport::Unsupported(array));
+        }
+
+        let storage = ArrayRef::from_arrow(array.as_ref(), field.is_nullable())?;
+        Ok(ArrowImport::Imported(
+            ExtensionArray::new(ext_dtype.clone(), storage).into_array(),
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use std::sync::Arc;
+
+    use arrow_array::Array;
+    use arrow_array::ArrayRef as ArrowArrayRef;
+    use arrow_array::StringArray;
+    use arrow_array::cast::AsArray;
+    use arrow_schema::DataType;
+    use arrow_schema::Field;
+    use arrow_schema::extension::ExtensionType;
+    use arrow_schema::extension::Json as ArrowJson;
+    use vortex_array::EmptyMetadata;
+    use vortex_array::IntoArray;
+    use vortex_array::VortexSessionExecute;
+    use vortex_array::arrays::ExtensionArray;
+    use vortex_array::arrays::VarBinArray;
+    use vortex_array::arrow::ArrowSessionExt;
+    use vortex_array::dtype::Nullability;
+    use vortex_array::dtype::extension::ExtDType;
+    use vortex_error::VortexExpect;
+    use vortex_error::VortexResult;
+    use vortex_session::VortexSession;
+
+    use crate::Json;
+    use crate::initialize;
+
+    /// Export a JSON extension array to Arrow's canonical JSON extension.
+    #[test]
+    fn exports_json_extension_array_as_arrow_json() -> VortexResult<()> {
+        let session = VortexSession::empty();
+        initialize(&session);
+
+        let storage = VarBinArray::from_iter(
+            [Some("{\"id\":1}"), Some("{\"id\":2}")],
+            vortex_array::dtype::DType::Utf8(Nullability::NonNullable),
+        )
+        .into_array();
+        let ext_dtype = ExtDType::<Json>::try_new(EmptyMetadata, storage.dtype().clone())?.erased();
+
+        dbg!(&ext_dtype);
+        let array = ExtensionArray::new(ext_dtype, storage).into_array();
+
+        let field = session.arrow().to_arrow_field("data", array.dtype())?;
+        assert_eq!(field.extension_type_name(), Some(ArrowJson::NAME));
+        ArrowJson::try_new_from_field_metadata(field.data_type(), field.metadata())?;
+
+        dbg!(&field);
+
+        let exported = session.arrow().execute_arrow(
+            array,
+            Some(&field),
+            &mut session.create_execution_ctx(),
+        )?;
+
+        assert!(exported.data_type().is_string());
+
+        dbg!(exported.data_type());
+
+        let strings = exported.as_string_view();
+        assert_eq!(strings.value(0), "{\"id\":1}");
+        assert_eq!(strings.value(1), "{\"id\":2}");
+        Ok(())
+    }
+
+    /// Import Arrow's canonical JSON extension as a Vortex JSON extension array.
+    #[test]
+    fn imports_arrow_json_extension_array_as_vortex_json() -> VortexResult<()> {
+        let session = VortexSession::empty();
+        initialize(&session);
+
+        let mut field = Field::new("data", DataType::Utf8, false);
+        field.try_with_extension_type(ArrowJson::default())?;
+        let array = Arc::new(StringArray::from(vec!["{\"id\":1}", "{\"id\":2}"])) as ArrowArrayRef;
+
+        let imported = session.arrow().from_arrow_array(array, &field)?;
+        let ext_dtype = imported
+            .dtype()
+            .as_extension_opt()
+            .vortex_expect("expected JSON extension dtype");
+        assert!(ext_dtype.is::<Json>());
+
+        let exported = session.arrow().execute_arrow(
+            imported,
+            Some(&field),
+            &mut session.create_execution_ctx(),
+        )?;
+        let strings = exported.as_string::<i32>();
+        assert_eq!(strings.value(0), "{\"id\":1}");
+        assert_eq!(strings.value(1), "{\"id\":2}");
+        Ok(())
+    }
+}
diff --git a/vortex-json/src/dtype.rs b/vortex-json/src/dtype.rs
new file mode 100644
index 00000000000..2c2a6663db0
--- /dev/null
+++ b/vortex-json/src/dtype.rs
@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Extension dtype definition for the JSON type
+
+use vortex_array::EmptyMetadata;
+use vortex_array::dtype::extension::ExtDType;
+use vortex_array::dtype::extension::ExtId;
+use vortex_array::dtype::extension::ExtVTable;
+use vortex_array::scalar::ScalarValue;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_ensure;
+
+/// JSON logical type backed by UTF-8 string storage.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct Json;
+
+impl ExtVTable for Json {
+    type Metadata = EmptyMetadata;
+    type NativeValue<'a> = &'a str;
+
+    fn id(&self) -> ExtId {
+        ExtId::new("vortex.json")
+    }
+
+    fn serialize_metadata(&self, _metadata: &Self::Metadata) -> VortexResult<Vec<u8>> {
+        Ok(vec![])
+    }
+
+    fn deserialize_metadata(&self, metadata: &[u8]) -> VortexResult<Self::Metadata> {
+        vortex_ensure!(metadata.is_empty(), "JSON metadata must be empty");
+        Ok(EmptyMetadata)
+    }
+
+    fn validate_dtype(ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
+        vortex_ensure!(
+            ext_dtype.storage_dtype().is_utf8(),
+            "JSON storage dtype must be utf8, got {}",
+            ext_dtype.storage_dtype()
+        );
+        Ok(())
+    }
+
+    fn unpack_native<'a>(
+        _ext_dtype: &'a ExtDType<Self>,
+        storage_value: &'a ScalarValue,
+    ) -> VortexResult<Self::NativeValue<'a>> {
+        let ScalarValue::Utf8(value) = storage_value else {
+            vortex_bail!("JSON storage scalar must be utf8, got {storage_value}");
+        };
+        Ok(value.as_str())
+    }
+}
diff --git a/vortex-json/src/lib.rs b/vortex-json/src/lib.rs
new file mode 100644
index 00000000000..fc7b0b1c9b3
--- /dev/null
+++ b/vortex-json/src/lib.rs
@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![warn(missing_docs)]
+#![warn(clippy::missing_docs_in_private_items)]
+#![warn(clippy::missing_errors_doc)]
+#![warn(clippy::missing_panics_doc)]
+#![warn(clippy::missing_safety_doc)]
+
+//! Extension type and related functionality for a JSON extension type for Vortex.
+
+mod arrow;
+mod dtype;
+
+use std::sync::Arc;
+
+pub use dtype::Json;
+use vortex_array::arrow::ArrowSessionExt;
+use vortex_array::dtype::session::DTypeSessionExt;
+use vortex_session::VortexSession;
+
+/// Register JSON extension support with a session.
+pub fn initialize(session: &VortexSession) {
+    session.dtypes().register(Json);
+    session.arrow().register_exporter(Arc::new(Json));
+    session.arrow().register_importer(Arc::new(Json));
+}
diff --git a/vortex-layout/src/children.rs b/vortex-layout/src/children.rs
index 21758d0c100..9dbc993c602 100644
--- a/vortex-layout/src/children.rs
+++ b/vortex-layout/src/children.rs
@@ -7,6 +7,7 @@ use std::sync::Arc;
 
 use flatbuffers::Follow;
 use itertools::Itertools;
+use once_cell::sync::OnceCell;
 use vortex_array::dtype::DType;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
@@ -61,7 +62,6 @@ impl LayoutChildren for Arc<dyn LayoutChildren> {
 }
 
 /// An implementation of [`LayoutChildren`] for in-memory owned children.
-/// See also [`ViewLayoutChildren`] for lazily deserialized children from flatbuffers.
 #[derive(Clone)]
 pub(crate) struct OwnedLayoutChildren(Vec<LayoutRef>);
 
@@ -105,6 +105,7 @@ pub(crate) struct ViewedLayoutChildren {
     layout_read_ctx: ReadContext,
     layouts: LayoutRegistry,
     allow_unknown: bool,
+    cache: Arc<[OnceCell<LayoutRef>]>,
 }
 
 impl ViewedLayoutChildren {
@@ -121,6 +122,12 @@ impl ViewedLayoutChildren {
         layouts: LayoutRegistry,
         allow_unknown: bool,
     ) -> Self {
+        // SAFETY: guaranteed by caller
+        let nchildren = unsafe { fbl::Layout::follow(flatbuffer.as_ref(), flatbuffer_loc) }
+            .children()
+            .unwrap_or_default()
+            .len();
+        let cache = vec![OnceCell::new(); nchildren].into_boxed_slice().into();
         Self {
             flatbuffer,
             flatbuffer_loc,
@@ -128,6 +135,7 @@ impl ViewedLayoutChildren {
             layout_read_ctx,
             layouts,
             allow_unknown,
+            cache,
         }
     }
 
@@ -184,47 +192,55 @@ impl LayoutChildren for ViewedLayoutChildren {
         if idx >= self.nchildren() {
             vortex_bail!("Child index out of bounds: {} of {}", idx, self.nchildren());
         }
-        let fb_child = self.flatbuffer().children().unwrap_or_default().get(idx);
 
-        let viewed_children = ViewedLayoutChildren {
-            flatbuffer: self.flatbuffer.clone(),
-            flatbuffer_loc: fb_child._tab.loc(),
-            array_read_ctx: self.array_read_ctx.clone(),
-            layout_read_ctx: self.layout_read_ctx.clone(),
-            layouts: self.layouts.clone(),
-            allow_unknown: self.allow_unknown,
-        };
+        let layout_ref = self.cache[idx].get_or_try_init(|| {
+            let fb_child = self.flatbuffer().children().unwrap_or_default().get(idx);
 
-        let encoding_id = self
-            .layout_read_ctx
-            .resolve(fb_child.encoding())
-            .ok_or_else(|| vortex_err!("Encoding not found: {}", fb_child.encoding()))?;
-        let Some(encoding) = self.layouts.find(&encoding_id) else {
-            if self.allow_unknown {
-                return viewed_children.foreign_layout_from_fb(fb_child, dtype);
-            }
-            return Err(vortex_err!(
-                "Encoding not found in registry: {}",
-                fb_child.encoding()
-            ));
-        };
-
-        encoding.build(
-            dtype,
-            fb_child.row_count(),
-            fb_child
-                .metadata()
-                .map(|m| m.bytes())
-                .unwrap_or_else(|| &[]),
-            fb_child
-                .segments()
-                .unwrap_or_default()
-                .iter()
-                .map(SegmentId::from)
-                .collect_vec(),
-            &viewed_children,
-            &self.array_read_ctx,
-        )
+            // SAFETY: same validated flatbuffer; fb_child._tab.loc() is a valid offset
+            // We need this to avoid re-initializing cache here
+            let viewed_children = unsafe {
+                ViewedLayoutChildren::new_unchecked(
+                    self.flatbuffer.clone(),
+                    fb_child._tab.loc(),
+                    self.array_read_ctx.clone(),
+                    self.layout_read_ctx.clone(),
+                    self.layouts.clone(),
+                    self.allow_unknown,
+                )
+            };
+
+            let encoding_id = self
+                .layout_read_ctx
+                .resolve(fb_child.encoding())
+                .ok_or_else(|| vortex_err!("Encoding not found: {}", fb_child.encoding()))?;
+            let Some(encoding) = self.layouts.find(&encoding_id) else {
+                if self.allow_unknown {
+                    return viewed_children.foreign_layout_from_fb(fb_child, dtype);
+                }
+                return Err(vortex_err!(
+                    "Encoding not found in registry: {}",
+                    fb_child.encoding()
+                ));
+            };
+
+            encoding.build(
+                dtype,
+                fb_child.row_count(),
+                fb_child
+                    .metadata()
+                    .map(|m| m.bytes())
+                    .unwrap_or_else(|| &[]),
+                fb_child
+                    .segments()
+                    .unwrap_or_default()
+                    .iter()
+                    .map(SegmentId::from)
+                    .collect_vec(),
+                &viewed_children,
+                &self.array_read_ctx,
+            )
+        })?;
+        Ok(Arc::clone(layout_ref))
     }
 
     fn child_row_count(&self, idx: usize) -> u64 {
@@ -238,6 +254,6 @@ impl LayoutChildren for ViewedLayoutChildren {
     }
 
     fn nchildren(&self) -> usize {
-        self.flatbuffer().children().unwrap_or_default().len()
+        self.cache.len()
     }
 }
diff --git a/vortex-layout/src/layout.rs b/vortex-layout/src/layout.rs
index 11f0afd629c..7e4caaa1168 100644
--- a/vortex-layout/src/layout.rs
+++ b/vortex-layout/src/layout.rs
@@ -19,6 +19,7 @@ use vortex_session::registry::Id;
 
 use crate::LayoutEncodingId;
 use crate::LayoutEncodingRef;
+use crate::LayoutReaderContext;
 use crate::LayoutReaderRef;
 use crate::VTable;
 use crate::display::DisplayLayoutTree;
@@ -63,11 +64,26 @@ pub trait Layout: 'static + Send + Sync + Debug + private::Sealed {
     /// Get the segment IDs for this layout.
     fn segment_ids(&self) -> Vec<SegmentId>;
 
+    /// Construct a new reader for this layout.
+    ///
+    /// - `name` — human-readable label for this reader, propagated to child readers
+    ///   (typically by appending a path component) and surfaced in tracing/debug output.
+    /// - `segment_source` — source of segment bytes for this and any descendant readers
+    ///   constructed from the returned reader; recursive callers should pass the same
+    ///   source through.
+    /// - `session` — the [`VortexSession`] hosting the encoding/scalar/layout registries
+    ///   and execution context the reader needs at evaluation time.
+    /// - `ctx` — id-keyed dependency registry threaded through reader construction (see
+    ///   [`LayoutReaderContext`]). Top-level callers (file open, tests) typically pass
+    ///   `&LayoutReaderContext::new()`; recursive callers inside layout implementations
+    ///   must propagate the `ctx` they were handed so ancestor-published values reach
+    ///   descendants.
     fn new_reader(
         &self,
         name: Arc<str>,
         segment_source: Arc<dyn SegmentSource>,
         session: &VortexSession,
+        ctx: &LayoutReaderContext,
     ) -> VortexResult<LayoutReaderRef>;
 }
 
@@ -311,8 +327,9 @@ impl<V: VTable> Layout for LayoutAdapter<V> {
         name: Arc<str>,
         segment_source: Arc<dyn SegmentSource>,
         session: &VortexSession,
+        ctx: &LayoutReaderContext,
     ) -> VortexResult<LayoutReaderRef> {
-        V::new_reader(&self.0, name, segment_source, session)
+        V::new_reader(&self.0, name, segment_source, session, ctx)
     }
 }
 
diff --git a/vortex-layout/src/layouts/chunked/mod.rs b/vortex-layout/src/layouts/chunked/mod.rs
index 82fcb650607..ee37cf87411 100644
--- a/vortex-layout/src/layouts/chunked/mod.rs
+++ b/vortex-layout/src/layouts/chunked/mod.rs
@@ -16,6 +16,7 @@ use vortex_session::registry::ReadContext;
 use crate::LayoutChildType;
 use crate::LayoutEncodingRef;
 use crate::LayoutId;
+use crate::LayoutReaderContext;
 use crate::LayoutReaderRef;
 use crate::LayoutRef;
 use crate::VTable;
@@ -74,12 +75,14 @@ impl VTable for Chunked {
         name: Arc<str>,
         segment_source: Arc<dyn SegmentSource>,
         session: &VortexSession,
+        ctx: &LayoutReaderContext,
     ) -> VortexResult<LayoutReaderRef> {
         Ok(Arc::new(ChunkedReader::new(
             layout.clone(),
             name,
             segment_source,
             session,
+            ctx.clone(),
         )))
     }
 
@@ -103,10 +106,9 @@ impl VTable for Chunked {
         let new_children = OwnedLayoutChildren::layout_children(children);
 
         // Recalculate chunk offsets based on new children
-        let mut chunk_offsets = Vec::with_capacity(new_children.nchildren() + 1);
-        chunk_offsets.push(0);
+        let mut chunk_offsets = vec![0; new_children.nchildren() + 1];
         for i in 0..new_children.nchildren() {
-            chunk_offsets.push(chunk_offsets[i] + new_children.child_row_count(i));
+            chunk_offsets[i + 1] = chunk_offsets[i] + new_children.child_row_count(i);
         }
 
         layout.children = new_children;
@@ -132,12 +134,11 @@ pub struct ChunkedLayout {
 
 impl ChunkedLayout {
     pub fn new(row_count: u64, dtype: DType, children: Arc<dyn LayoutChildren>) -> Self {
-        let mut chunk_offsets = Vec::with_capacity(children.nchildren() + 1);
-
-        chunk_offsets.push(0);
+        let mut chunk_offsets = vec![0; children.nchildren() + 1];
         for i in 0..children.nchildren() {
-            chunk_offsets.push(chunk_offsets[i] + children.child_row_count(i));
+            chunk_offsets[i + 1] = chunk_offsets[i] + children.child_row_count(i);
         }
+
         assert_eq!(
             chunk_offsets[children.nchildren()],
             row_count,
diff --git a/vortex-layout/src/layouts/chunked/reader.rs b/vortex-layout/src/layouts/chunked/reader.rs
index 39bd8b27b7c..4d095cfee37 100644
--- a/vortex-layout/src/layouts/chunked/reader.rs
+++ b/vortex-layout/src/layouts/chunked/reader.rs
@@ -26,6 +26,7 @@ use vortex_error::vortex_panic;
 use vortex_mask::Mask;
 use vortex_session::VortexSession;
 
+use crate::LayoutReaderContext;
 use crate::LayoutReaderRef;
 use crate::LazyReaderChildren;
 use crate::layouts::chunked::ChunkedLayout;
@@ -39,8 +40,6 @@ pub struct ChunkedReader {
     layout: ChunkedLayout,
     name: Arc<str>,
     lazy_children: LazyReaderChildren,
-    /// Row offset for each chunk
-    chunk_offsets: Vec<u64>,
 }
 
 static UNKNOWN: LazyLock<Arc<str>> = LazyLock::new(|| Arc::from("chunked-child"));
@@ -51,15 +50,9 @@ impl ChunkedReader {
         name: Arc<str>,
         segment_source: Arc<dyn SegmentSource>,
         session: &VortexSession,
+        ctx: LayoutReaderContext,
     ) -> Self {
         let nchildren = layout.nchildren();
-
-        let mut chunk_offsets = vec![0; nchildren + 1];
-        for i in 1..nchildren {
-            chunk_offsets[i] = chunk_offsets[i - 1] + layout.children.child_row_count(i - 1);
-        }
-        chunk_offsets[nchildren] = layout.row_count();
-
         let dtypes = vec![layout.dtype.clone(); nchildren];
 
         // format!() has non-marginal overhead for short queries like random
@@ -78,13 +71,13 @@ impl ChunkedReader {
             names,
             segment_source,
             session.clone(),
+            ctx,
         );
 
         Self {
             layout,
             name,
             lazy_children,
-            chunk_offsets,
         }
     }
 
@@ -94,22 +87,25 @@ impl ChunkedReader {
     }
 
     fn chunk_offset(&self, idx: usize) -> u64 {
-        self.chunk_offsets.get(idx).copied().unwrap_or_else(|| {
+        if idx >= self.layout.chunk_offsets.len() {
             vortex_panic!(
                 "Internal error: Chunk offset {idx} out of bounds (num_children: {}, num_offsets: {}). \
                 This indicates a bug in ChunkedReader initialization or chunk_range calculation.",
                 self.layout.nchildren(),
-                self.chunk_offsets.len()
+                self.layout.chunk_offsets.len()
             )
-        })
+        }
+        self.layout.chunk_offsets[idx]
     }
 
     fn chunk_range(&self, row_range: &Range<u64>) -> Range<usize> {
         let start_chunk = self
+            .layout
             .chunk_offsets
             .binary_search(&row_range.start)
             .unwrap_or_else(|x| x.saturating_sub(1));
         let end_chunk = self
+            .layout
             .chunk_offsets
             .binary_search(&row_range.end)
             .unwrap_or_else(|x| x);
@@ -455,7 +451,12 @@ mod test {
     ) {
         let layout = nested_chunked_layout();
         let reader = layout
-            .new_reader("".into(), Arc::new(TestSegments::default()), &SESSION)
+            .new_reader(
+                "".into(),
+                Arc::new(TestSegments::default()),
+                &SESSION,
+                &Default::default(),
+            )
             .unwrap();
 
         let splits = SplitBy::Layout
@@ -471,7 +472,7 @@ mod test {
     ) {
         block_on(|_h| async {
             let result = layout
-                .new_reader("".into(), segments, &SESSION)
+                .new_reader("".into(), segments, &SESSION, &Default::default())
                 .unwrap()
                 .projection_evaluation(
                     &(0..layout.row_count()),
diff --git a/vortex-layout/src/layouts/dict/mod.rs b/vortex-layout/src/layouts/dict/mod.rs
index 7928b447fa9..5fb4ea080b4 100644
--- a/vortex-layout/src/layouts/dict/mod.rs
+++ b/vortex-layout/src/layouts/dict/mod.rs
@@ -92,12 +92,14 @@ impl VTable for Dict {
         name: Arc<str>,
         segment_source: Arc<dyn SegmentSource>,
         session: &VortexSession,
+        ctx: &crate::LayoutReaderContext,
     ) -> VortexResult<LayoutReaderRef> {
         Ok(Arc::new(DictReader::try_new(
             layout.clone(),
             name,
             segment_source,
             session.clone(),
+            ctx.clone(),
         )?))
     }
 
diff --git a/vortex-layout/src/layouts/dict/reader.rs b/vortex-layout/src/layouts/dict/reader.rs
index 5687274bd90..002b4b1e902 100644
--- a/vortex-layout/src/layouts/dict/reader.rs
+++ b/vortex-layout/src/layouts/dict/reader.rs
@@ -58,17 +58,21 @@ impl DictReader {
         name: Arc<str>,
         segment_source: Arc<dyn SegmentSource>,
         session: VortexSession,
+        ctx: crate::LayoutReaderContext,
     ) -> VortexResult<Self> {
         let values_len = usize::try_from(layout.values.row_count())?;
         let values = layout.values.new_reader(
             format!("{name}.values").into(),
             Arc::clone(&segment_source),
             &session,
+            &ctx,
+        )?;
+        let codes = layout.codes.new_reader(
+            format!("{name}.codes").into(),
+            segment_source,
+            &session,
+            &ctx,
         )?;
-        let codes =
-            layout
-                .codes
-                .new_reader(format!("{name}.codes").into(), segment_source, &session)?;
 
         Ok(Self {
             layout,
@@ -370,7 +374,7 @@ mod tests {
             );
             assert!(layout.encoding_id() == LayoutId::new("vortex.dict"));
             let actual = layout
-                .new_reader("".into(), segments, &session)
+                .new_reader("".into(), segments, &session, &Default::default())
                 .unwrap()
                 .projection_evaluation(
                     &(0..layout.row_count()),
@@ -454,7 +458,7 @@ mod tests {
                 )),
             );
             let mask = layout
-                .new_reader("".into(), segments, &session)
+                .new_reader("".into(), segments, &session, &Default::default())
                 .unwrap()
                 .filter_evaluation(&(0..3), &filter, MaskFuture::new_true(3))
                 .unwrap()
@@ -515,7 +519,7 @@ mod tests {
             let expression = is_not_null(root());
             assert_eq!(layout.encoding_id(), LayoutId::new("vortex.dict"));
             let actual = layout
-                .new_reader("".into(), segments, &session)
+                .new_reader("".into(), segments, &session, &Default::default())
                 .unwrap()
                 .projection_evaluation(
                     &(0..layout.row_count()),
diff --git a/vortex-layout/src/layouts/flat/mod.rs b/vortex-layout/src/layouts/flat/mod.rs
index b167e633170..a652f82fe61 100644
--- a/vortex-layout/src/layouts/flat/mod.rs
+++ b/vortex-layout/src/layouts/flat/mod.rs
@@ -87,6 +87,7 @@ impl VTable for Flat {
         name: Arc<str>,
         segment_source: Arc<dyn SegmentSource>,
         session: &VortexSession,
+        _ctx: &crate::LayoutReaderContext,
     ) -> VortexResult<LayoutReaderRef> {
         Ok(Arc::new(FlatReader::new(
             layout.clone(),
diff --git a/vortex-layout/src/layouts/flat/reader.rs b/vortex-layout/src/layouts/flat/reader.rs
index 954bbe5ab5c..3f3527aaa6a 100644
--- a/vortex-layout/src/layouts/flat/reader.rs
+++ b/vortex-layout/src/layouts/flat/reader.rs
@@ -148,7 +148,8 @@ impl LayoutReader for FlatReader {
                 array = array.slice(row_range.clone())?;
             }
 
-            let array_mask = if mask.density() < EXPR_EVAL_THRESHOLD {
+            let mask_density = mask.density();
+            let array_mask = if mask_density < EXPR_EVAL_THRESHOLD {
                 // We have the choice to apply the filter or the expression first, we apply the
                 // expression first so that it can try pushing down itself and then the filter
                 // after this.
@@ -171,7 +172,7 @@ impl LayoutReader for FlatReader {
                 "Flat mask evaluation {} - {} (mask = {}) => {}",
                 name,
                 expr,
-                mask.density(),
+                mask_density,
                 array_mask.density(),
             );
 
@@ -276,7 +277,7 @@ mod test {
             );
 
             let result = layout
-                .new_reader("".into(), segments, &SESSION)?
+                .new_reader("".into(), segments, &SESSION, &Default::default())?
                 .projection_evaluation(
                     &(0..layout.row_count()),
                     &root(),
@@ -313,7 +314,7 @@ mod test {
 
             let expr = gt(root(), lit(3i32));
             let result = layout
-                .new_reader("".into(), segments, &SESSION)
+                .new_reader("".into(), segments, &SESSION, &Default::default())
                 .unwrap()
                 .projection_evaluation(
                     &(0..layout.row_count()),
@@ -350,7 +351,7 @@ mod test {
                 .unwrap();
 
             let result = layout
-                .new_reader("".into(), segments, &SESSION)
+                .new_reader("".into(), segments, &SESSION, &Default::default())
                 .unwrap()
                 .projection_evaluation(&(2..4), &root(), MaskFuture::new_true(2))
                 .unwrap()
diff --git a/vortex-layout/src/layouts/flat/writer.rs b/vortex-layout/src/layouts/flat/writer.rs
index a50d8a27416..f390555a4e7 100644
--- a/vortex-layout/src/layouts/flat/writer.rs
+++ b/vortex-layout/src/layouts/flat/writer.rs
@@ -260,7 +260,7 @@ mod tests {
                 .unwrap();
 
             let result = layout
-                .new_reader("".into(), segments, &SESSION)
+                .new_reader("".into(), segments, &SESSION, &Default::default())
                 .unwrap()
                 .projection_evaluation(
                     &(0..layout.row_count()),
@@ -311,7 +311,7 @@ mod tests {
                 .unwrap();
 
             let result = layout
-                .new_reader("".into(), segments, &SESSION)
+                .new_reader("".into(), segments, &SESSION, &Default::default())
                 .unwrap()
                 .projection_evaluation(
                     &(0..layout.row_count()),
@@ -384,7 +384,7 @@ mod tests {
 
             // We should be able to read the array we just wrote.
             let result: ArrayRef = layout
-                .new_reader("".into(), segments, &SESSION)
+                .new_reader("".into(), segments, &SESSION, &Default::default())
                 .unwrap()
                 .projection_evaluation(
                     &(0..layout.row_count()),
diff --git a/vortex-layout/src/layouts/foreign/mod.rs b/vortex-layout/src/layouts/foreign/mod.rs
index 9abacc8b26e..6e0a351b41b 100644
--- a/vortex-layout/src/layouts/foreign/mod.rs
+++ b/vortex-layout/src/layouts/foreign/mod.rs
@@ -171,6 +171,7 @@ impl Layout for ForeignLayout {
         _name: Arc<str>,
         _segment_source: Arc<dyn SegmentSource>,
         _session: &VortexSession,
+        _ctx: &crate::LayoutReaderContext,
     ) -> VortexResult<LayoutReaderRef> {
         vortex_bail!(
             "Cannot read unknown layout encoding '{}'",
diff --git a/vortex-layout/src/layouts/row_idx/expr.rs b/vortex-layout/src/layouts/row_idx/expr.rs
index 2d85d6e43f5..95ddce3d762 100644
--- a/vortex-layout/src/layouts/row_idx/expr.rs
+++ b/vortex-layout/src/layouts/row_idx/expr.rs
@@ -17,6 +17,7 @@ use vortex_array::scalar_fn::ScalarFnVTable;
 use vortex_array::scalar_fn::ScalarFnVTableExt;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
+use vortex_session::registry::CachedId;
 
 #[derive(Clone)]
 pub struct RowIdx;
@@ -25,7 +26,8 @@ impl ScalarFnVTable for RowIdx {
     type Options = EmptyOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.row_idx")
+        static ID: CachedId = CachedId::new("vortex.row_idx");
+        *ID
     }
 
     fn arity(&self, _options: &Self::Options) -> Arity {
diff --git a/vortex-layout/src/layouts/row_idx/mod.rs b/vortex-layout/src/layouts/row_idx/mod.rs
index 90570101827..3814c2f8093 100644
--- a/vortex-layout/src/layouts/row_idx/mod.rs
+++ b/vortex-layout/src/layouts/row_idx/mod.rs
@@ -370,7 +370,9 @@ mod tests {
             let expr = eq(root(), lit(3i32));
             let result = RowIdxLayoutReader::new(
                 0,
-                layout.new_reader("".into(), segments, &SESSION).unwrap(),
+                layout
+                    .new_reader("".into(), segments, &SESSION, &Default::default())
+                    .unwrap(),
                 SESSION.clone(),
             )
             .projection_evaluation(
@@ -411,7 +413,9 @@ mod tests {
             let expr = gt(row_idx(), lit(3u64));
             let result = RowIdxLayoutReader::new(
                 0,
-                layout.new_reader("".into(), segments, &SESSION).unwrap(),
+                layout
+                    .new_reader("".into(), segments, &SESSION, &Default::default())
+                    .unwrap(),
                 SESSION.clone(),
             )
             .projection_evaluation(
@@ -456,7 +460,9 @@ mod tests {
 
             let result = RowIdxLayoutReader::new(
                 0,
-                layout.new_reader("".into(), segments, &SESSION).unwrap(),
+                layout
+                    .new_reader("".into(), segments, &SESSION, &Default::default())
+                    .unwrap(),
                 SESSION.clone(),
             )
             .projection_evaluation(
diff --git a/vortex-layout/src/layouts/struct_/mod.rs b/vortex-layout/src/layouts/struct_/mod.rs
index 29843f096d8..39ada8ccaec 100644
--- a/vortex-layout/src/layouts/struct_/mod.rs
+++ b/vortex-layout/src/layouts/struct_/mod.rs
@@ -114,12 +114,14 @@ impl VTable for Struct {
         name: Arc<str>,
         segment_source: Arc<dyn SegmentSource>,
         session: &VortexSession,
+        ctx: &crate::LayoutReaderContext,
     ) -> VortexResult<LayoutReaderRef> {
         Ok(Arc::new(StructReader::try_new(
             layout.clone(),
             name,
             segment_source,
             session.session(),
+            ctx.clone(),
         )?))
     }
 
diff --git a/vortex-layout/src/layouts/struct_/reader.rs b/vortex-layout/src/layouts/struct_/reader.rs
index 6364d40b442..d27bd3746e7 100644
--- a/vortex-layout/src/layouts/struct_/reader.rs
+++ b/vortex-layout/src/layouts/struct_/reader.rs
@@ -68,6 +68,7 @@ impl StructReader {
         name: Arc<str>,
         segment_source: Arc<dyn SegmentSource>,
         session: VortexSession,
+        ctx: crate::LayoutReaderContext,
     ) -> VortexResult<Self> {
         let struct_dt = layout.struct_fields();
 
@@ -99,6 +100,7 @@ impl StructReader {
             names,
             Arc::clone(&segment_source),
             session.clone(),
+            ctx,
         );
 
         // Create an expanded root expression that contains all fields of the struct.
@@ -155,21 +157,17 @@ impl StructReader {
     /// Utility for partitioning an expression over the fields of a struct.
     fn partition_expr(&self, expr: Expression) -> VortexResult<Partitioned> {
         let key = ExactExpr(expr.clone());
-
-        if let Some(entry) = self.partitioned_expr_cache.get(&key)
-            && let Some(partitioning) = entry.value().get()
-        {
-            return Ok(partitioning.clone());
+        let binding = self
+            .partitioned_expr_cache
+            .entry(key)
+            .or_insert_with(|| Arc::new(OnceLock::new()));
+        let entry = binding.value();
+        if let Some(value) = entry.get() {
+            return Ok(value.clone());
         }
-
         let result = self.compute_partitioned_expr(expr)?;
-
-        self.partitioned_expr_cache
-            .entry(key)
-            .or_insert_with(|| Arc::new(OnceLock::new()))
-            .get_or_init(|| result.clone());
-
-        Ok(result)
+        let result = entry.get_or_init(|| result);
+        Ok(result.clone())
     }
 
     fn compute_partitioned_expr(&self, expr: Expression) -> VortexResult<Partitioned> {
@@ -616,7 +614,9 @@ mod tests {
     fn test_struct_layout_or(
         #[from(struct_layout)] (segments, layout): (Arc<dyn SegmentSource>, LayoutRef),
     ) {
-        let reader = layout.new_reader("".into(), segments, &SESSION).unwrap();
+        let reader = layout
+            .new_reader("".into(), segments, &SESSION, &Default::default())
+            .unwrap();
         let filt = or(
             eq(col("a"), lit(7)),
             or(eq(col("b"), lit(5)), eq(col("a"), lit(3))),
@@ -634,7 +634,9 @@ mod tests {
     fn test_struct_layout(
         #[from(struct_layout)] (segments, layout): (Arc<dyn SegmentSource>, LayoutRef),
     ) {
-        let reader = layout.new_reader("".into(), segments, &SESSION).unwrap();
+        let reader = layout
+            .new_reader("".into(), segments, &SESSION, &Default::default())
+            .unwrap();
         let expr = gt(get_item("a", root()), get_item("b", root()));
         let result = block_on(|_| {
             reader
@@ -650,7 +652,9 @@ mod tests {
     fn test_struct_layout_row_mask(
         #[from(struct_layout)] (segments, layout): (Arc<dyn SegmentSource>, LayoutRef),
     ) {
-        let reader = layout.new_reader("".into(), segments, &SESSION).unwrap();
+        let reader = layout
+            .new_reader("".into(), segments, &SESSION, &Default::default())
+            .unwrap();
         let expr = gt(get_item("a", root()), get_item("b", root()));
         let result = block_on(|_| {
             reader
@@ -672,7 +676,9 @@ mod tests {
         #[from(struct_layout)] (segments, layout): (Arc<dyn SegmentSource>, LayoutRef),
     ) {
         let mut ctx = LEGACY_SESSION.create_execution_ctx();
-        let reader = layout.new_reader("".into(), segments, &SESSION).unwrap();
+        let reader = layout
+            .new_reader("".into(), segments, &SESSION, &Default::default())
+            .unwrap();
         let expr = pack(
             [("a", get_item("a", root())), ("b", get_item("b", root()))],
             Nullability::NonNullable,
@@ -711,7 +717,9 @@ mod tests {
         #[from(null_struct_layout)] (segments, layout): (Arc<dyn SegmentSource>, LayoutRef),
     ) {
         // Read the layout source from the top.
-        let reader = layout.new_reader("".into(), segments, &SESSION).unwrap();
+        let reader = layout
+            .new_reader("".into(), segments, &SESSION, &Default::default())
+            .unwrap();
         let expr = get_item("a", root());
         let project = reader
             .projection_evaluation(&(0..3), &expr, MaskFuture::new_true(3))
@@ -742,7 +750,9 @@ mod tests {
         // Project out the nested struct field.
         // The projection should preserve the nulls of the `b` struct when we select out the
         // child column `c`.
-        let reader = layout.new_reader("".into(), segments, &SESSION).unwrap();
+        let reader = layout
+            .new_reader("".into(), segments, &SESSION, &Default::default())
+            .unwrap();
         let expr = select(
             vec![FieldName::from("c")],
             get_item("b", get_item("a", root())),
@@ -803,7 +813,9 @@ mod tests {
     fn test_empty_struct(
         #[from(empty_struct)] (segments, layout): (Arc<dyn SegmentSource>, LayoutRef),
     ) {
-        let reader = layout.new_reader("".into(), segments, &SESSION).unwrap();
+        let reader = layout
+            .new_reader("".into(), segments, &SESSION, &Default::default())
+            .unwrap();
         let expr = pack(Vec::<(String, Expression)>::new(), Nullability::Nullable);
 
         let project = reader
@@ -854,7 +866,9 @@ mod tests {
         })
         .unwrap();
 
-        let reader = layout.new_reader("".into(), segments, &SESSION).unwrap();
+        let reader = layout
+            .new_reader("".into(), segments, &SESSION, &Default::default())
+            .unwrap();
 
         // DType mismatch: "age" is u8 but literal is i32
         let filt = eq(col("age"), lit(67i32));
diff --git a/vortex-layout/src/layouts/zoned/mod.rs b/vortex-layout/src/layouts/zoned/mod.rs
index 697e55e968c..43f9410e831 100644
--- a/vortex-layout/src/layouts/zoned/mod.rs
+++ b/vortex-layout/src/layouts/zoned/mod.rs
@@ -115,12 +115,14 @@ impl VTable for Zoned {
         name: Arc<str>,
         segment_source: Arc<dyn SegmentSource>,
         session: &VortexSession,
+        ctx: &crate::LayoutReaderContext,
     ) -> VortexResult<LayoutReaderRef> {
         Ok(Arc::new(ZonedReader::try_new(
             layout.clone(),
             name,
             segment_source,
             session.clone(),
+            ctx.clone(),
         )?))
     }
 
diff --git a/vortex-layout/src/layouts/zoned/reader.rs b/vortex-layout/src/layouts/zoned/reader.rs
index 7c3e7fbd1fe..9f93d5cb1d9 100644
--- a/vortex-layout/src/layouts/zoned/reader.rs
+++ b/vortex-layout/src/layouts/zoned/reader.rs
@@ -42,6 +42,7 @@ impl ZonedReader {
         name: Arc<str>,
         segment_source: Arc<dyn SegmentSource>,
         session: VortexSession,
+        ctx: crate::LayoutReaderContext,
     ) -> VortexResult<Self> {
         let dtypes = vec![
             layout.dtype.clone(),
@@ -54,6 +55,7 @@ impl ZonedReader {
             names,
             Arc::clone(&segment_source),
             session.clone(),
+            ctx,
         ));
 
         Ok(Self {
@@ -172,6 +174,7 @@ impl LayoutReader for ZonedReader {
             assert_eq!(stats_mask.len(), mask.len(), "Mask length mismatch");
 
             // Intersect the masks.
+            let mask_density = mask.density();
             let mut stats_mask = mask.bitand(&stats_mask);
 
             // Forward to data child for further pruning.
@@ -184,7 +187,7 @@ impl LayoutReader for ZonedReader {
                 "Stats evaluation approx {} - {} (mask = {}) => {}",
                 name,
                 expr,
-                mask.density(),
+                mask_density,
                 stats_mask.density(),
             );
 
@@ -307,7 +310,7 @@ mod test {
         block_on(|handle| async {
             let session = session_with_handle(handle);
             let result = layout
-                .new_reader("".into(), segments, &session)
+                .new_reader("".into(), segments, &session, &Default::default())
                 .unwrap()
                 .projection_evaluation(
                     &(0..layout.row_count()),
@@ -330,7 +333,9 @@ mod test {
         block_on(|handle| async {
             let row_count = layout.row_count();
             let session = session_with_handle(handle);
-            let reader = layout.new_reader("".into(), segments, &session).unwrap();
+            let reader = layout
+                .new_reader("".into(), segments, &session, &Default::default())
+                .unwrap();
 
             // Choose a prune-able expression
             let expr = gt(root(), lit(7));
@@ -376,7 +381,8 @@ mod test {
         block_on(|handle| async {
             let row_count = legacy_layout.row_count();
             let session = session_with_handle(handle);
-            let reader = legacy_layout.new_reader("".into(), segments, &session)?;
+            let reader =
+                legacy_layout.new_reader("".into(), segments, &session, &Default::default())?;
 
             let result = reader
                 .pruning_evaluation(
diff --git a/vortex-layout/src/layouts/zoned/zone_map.rs b/vortex-layout/src/layouts/zoned/zone_map.rs
index a3719e8e17e..96154e69571 100644
--- a/vortex-layout/src/layouts/zoned/zone_map.rs
+++ b/vortex-layout/src/layouts/zoned/zone_map.rs
@@ -179,13 +179,13 @@ impl ZoneMap {
             return Ok(lit(0u64));
         }
 
-        // When the aggregate function does not support the column dtype the stat is
-        // not computable on this layout, so treat it the same as a missing stat and
-        // lower to a nullable "unknown" rather than failing the whole scan. Min/Max
-        // share their input dtype, so falling back to `input_dtype.as_nullable()`
-        // keeps the rewrite well-typed for the most common case.
-        let Some(return_dtype) = options.aggregate_fn().return_dtype(&input_dtype) else {
-            return Ok(null_expr(input_dtype.as_nullable()));
+        let return_dtype = match options.aggregate_fn().return_dtype(&input_dtype) {
+            Some(return_dtype) => return_dtype,
+            None => vortex_bail!(
+                "Aggregate function {} does not support input dtype {}",
+                options.aggregate_fn(),
+                input_dtype
+            ),
         };
 
         if !input_is_root {
@@ -277,6 +277,7 @@ mod tests {
     use vortex_array::arrays::StructArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::dtype::DType;
+    use vortex_array::dtype::DecimalDType;
     use vortex_array::dtype::FieldNames;
     use vortex_array::dtype::Nullability;
     use vortex_array::dtype::PType;
@@ -606,14 +607,14 @@ mod tests {
     }
 
     #[test]
-    fn unsupported_aggregate_input_dtype_lowers_to_unknown() {
-        // Regression test for issue #8189: a pruning predicate that contains a
-        // `StatFn(Max, $)` (or `Min`) over a column dtype that the aggregate
-        // function does not support (e.g. `FixedSizeList<Primitive>`) used to
-        // bail out of `lower_stat_fn` with "Aggregate function vortex.max() does
-        // not support input dtype ...", panicking the scan instead of treating
-        // the stat as unknown.
-        let elem_dtype = Arc::new(DType::Primitive(PType::I32, Nullability::Nullable));
+    fn fixed_size_list_min_max_stat_fn_lowers_to_unknown_mask() {
+        // Regression test for issue #8189: Min/Max is defined for FixedSizeList<T>
+        // when T is orderable. If the zone map does not carry the requested stat,
+        // lowering should produce an unknown typed null rather than rejecting the dtype.
+        let elem_dtype = Arc::new(DType::Decimal(
+            DecimalDType::new(10, 2),
+            Nullability::Nullable,
+        ));
         let column_dtype = DType::FixedSizeList(elem_dtype, 1, Nullability::Nullable);
 
         let zone_map = ZoneMap::try_new(
@@ -630,12 +631,36 @@ mod tests {
             .expect("max should have an aggregate function");
         let predicate = is_null(vortex_array::stats::stat(root(), max_fn));
 
-        // Must not panic; the unsupported StatFn lowers to a nullable null
-        // literal, so `is_null(...)` is true for every zone.
+        // Missing StatFn lowers to a nullable null literal, so `is_null(...)` is true for every zone.
         let mask = zone_map.prune(&predicate, &SESSION).unwrap();
         assert_arrays_eq!(mask.into_array(), BoolArray::from_iter([true, true, true]));
     }
 
+    #[test]
+    fn unsupported_aggregate_input_dtype_errors() {
+        let zone_map = ZoneMap::try_new(
+            DType::Null,
+            StructArray::try_new(FieldNames::empty(), vec![], 3, Validity::NonNullable).unwrap(),
+            Arc::new([]),
+            4,
+            10,
+        )
+        .unwrap();
+
+        let max_fn = Stat::Max
+            .aggregate_fn()
+            .expect("max should have an aggregate function");
+        let predicate = is_null(vortex_array::stats::stat(root(), max_fn));
+        let error = zone_map.prune(&predicate, &SESSION).unwrap_err();
+
+        assert!(
+            error
+                .to_string()
+                .contains("Aggregate function vortex.max() does not support input dtype null"),
+            "{error}"
+        );
+    }
+
     #[test]
     fn row_count_prunes_all_null_uniform_zones() {
         let zone_map = ZoneMap::try_new(
diff --git a/vortex-layout/src/lib.rs b/vortex-layout/src/lib.rs
index be1bad67236..aca3d36c04a 100644
--- a/vortex-layout/src/lib.rs
+++ b/vortex-layout/src/lib.rs
@@ -8,6 +8,7 @@ pub use encoding::*;
 pub use flatbuffers::*;
 pub use layout::*;
 pub use reader::*;
+pub use reader_context::*;
 pub use strategy::*;
 use vortex_session::registry::Context;
 pub use vtable::*;
@@ -18,6 +19,7 @@ mod encoding;
 mod flatbuffers;
 mod layout;
 mod reader;
+mod reader_context;
 pub mod scan;
 pub mod segments;
 pub mod sequence;
diff --git a/vortex-layout/src/reader.rs b/vortex-layout/src/reader.rs
index 5706fc0d964..c4f65c1c96c 100644
--- a/vortex-layout/src/reader.rs
+++ b/vortex-layout/src/reader.rs
@@ -20,6 +20,7 @@ use vortex_error::vortex_bail;
 use vortex_mask::Mask;
 use vortex_session::VortexSession;
 
+use crate::LayoutReaderContext;
 use crate::children::LayoutChildren;
 use crate::segments::SegmentSource;
 
@@ -207,6 +208,7 @@ pub struct LazyReaderChildren {
     names: Vec<Arc<str>>,
     segment_source: Arc<dyn SegmentSource>,
     session: VortexSession,
+    ctx: LayoutReaderContext,
     // TODO(ngates): we may want a hash map of some sort here?
     cache: Vec<OnceCell<LayoutReaderRef>>,
 }
@@ -218,6 +220,7 @@ impl LazyReaderChildren {
         names: Vec<Arc<str>>,
         segment_source: Arc<dyn SegmentSource>,
         session: VortexSession,
+        ctx: LayoutReaderContext,
     ) -> Self {
         let nchildren = children.nchildren();
         let cache = (0..nchildren).map(|_| OnceCell::new()).collect();
@@ -227,6 +230,7 @@ impl LazyReaderChildren {
             names,
             segment_source,
             session,
+            ctx,
             cache,
         }
     }
@@ -243,6 +247,7 @@ impl LazyReaderChildren {
                 Arc::clone(&self.names[idx]),
                 Arc::clone(&self.segment_source),
                 &self.session,
+                &self.ctx,
             )
         })
     }
diff --git a/vortex-layout/src/reader_context.rs b/vortex-layout/src/reader_context.rs
new file mode 100644
index 00000000000..8c4cfed5c93
--- /dev/null
+++ b/vortex-layout/src/reader_context.rs
@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::any::Any;
+use std::sync::Arc;
+
+use vortex_session::registry::Id;
+use vortex_utils::aliases::hash_map::HashMap;
+
+/// Per-reader-tree dependency context, threaded through [`crate::VTable::new_reader`].
+///
+/// Holds an [`Id`]-keyed registry of `Arc<dyn Any>` values. Ancestors publish via
+/// [`Self::with`]; descendants retrieve via [`Self::get`]. This is a *read-only* channel
+/// from the descendant's perspective — they can only consume what an ancestor chose to
+/// publish.
+///
+/// [`Self::with`] returns a derived context that copies the existing map and inserts or
+/// replaces one entry — original unchanged, so concurrent reader-tree constructions each
+/// derive their own context without races. Contexts are cheap to clone via internal `Arc`
+/// and can be captured by lazy children helpers.
+#[derive(Clone, Default)]
+pub struct LayoutReaderContext {
+    values: Arc<HashMap<Id, Arc<dyn Any + Send + Sync>>>,
+}
+
+impl std::fmt::Debug for LayoutReaderContext {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("LayoutReaderContext")
+            .field("ids", &self.values.keys().collect::<Vec<_>>())
+            .finish()
+    }
+}
+
+impl LayoutReaderContext {
+    /// Creates a new, empty context.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Returns a new context that publishes `value` under `id`.
+    ///
+    /// The original context is unchanged. If a value was already published under the
+    /// same `id`, the new one replaces it in the returned context — so two ancestors
+    /// using the same well-known static id give descendants "nearest ancestor wins".
+    pub fn with<T: Any + Send + Sync>(&self, id: Id, value: Arc<T>) -> Self {
+        let mut values = HashMap::clone(&self.values);
+        values.insert(id, value);
+        Self {
+            values: Arc::new(values),
+        }
+    }
+
+    /// Returns the value published under `id`, downcast to `T`. Returns `None` if no
+    /// ancestor published under that id, or if the published value is not a `T`.
+    pub fn get<T: Any + Send + Sync>(&self, id: Id) -> Option<Arc<T>> {
+        self.values
+            .get(&id)
+            .and_then(|v| Arc::clone(v).downcast::<T>().ok())
+    }
+}
diff --git a/vortex-layout/src/scan/multi.rs b/vortex-layout/src/scan/multi.rs
index 9442b72cf7a..8b8376b3b0b 100644
--- a/vortex-layout/src/scan/multi.rs
+++ b/vortex-layout/src/scan/multi.rs
@@ -382,7 +382,7 @@ fn reader_partition(
 
 /// A partition backed by a single [`LayoutReaderRef`] and a row range.
 ///
-/// On `execute()`, creates a [`ScanBuilder`][crate::ScanBuilder] over the row range, enabling
+/// On `execute()`, creates a [`ScanBuilder`] over the row range, enabling
 /// internal I/O pipelining and split-level parallelism within the reader.
 struct MultiLayoutPartition {
     reader: LayoutReaderRef,
diff --git a/vortex-layout/src/scan/scan_builder.rs b/vortex-layout/src/scan/scan_builder.rs
index a46bfa14e2f..d916003fc78 100644
--- a/vortex-layout/src/scan/scan_builder.rs
+++ b/vortex-layout/src/scan/scan_builder.rs
@@ -15,12 +15,9 @@ use futures::stream::BoxStream;
 use itertools::Itertools;
 use vortex_array::ArrayRef;
 use vortex_array::dtype::DType;
-use vortex_array::dtype::Field;
 use vortex_array::dtype::FieldMask;
-use vortex_array::dtype::FieldName;
-use vortex_array::dtype::FieldPath;
 use vortex_array::expr::Expression;
-use vortex_array::expr::analysis::immediate_access::immediate_scope_access;
+use vortex_array::expr::analysis::referenced_field_paths;
 use vortex_array::expr::root;
 use vortex_array::iter::ArrayIterator;
 use vortex_array::iter::ArrayIteratorAdapter;
@@ -267,9 +264,8 @@ impl<A: 'static + Send> ScanBuilder<A> {
             .transpose()?;
 
         // Construct field masks and compute the row splits of the scan.
-        let (filter_mask, projection_mask) =
-            filter_and_projection_masks(&projection, filter.as_ref(), layout_reader.dtype())?;
-        let field_mask: Vec<_> = [filter_mask, projection_mask].concat();
+        let field_mask =
+            referenced_field_masks(&projection, filter.as_ref(), layout_reader.dtype())?;
 
         let splits =
             if let Some(ranges) = attempt_split_ranges(&self.selection, self.row_range.as_ref()) {
@@ -412,40 +408,20 @@ impl<A: 'static + Send> Stream for LazyScanStream<A> {
 /// Compute masks of field paths referenced by the projection and filter in the scan.
 ///
 /// Projection and filter must be pre-simplified.
-pub fn filter_and_projection_masks(
+pub fn referenced_field_masks(
     projection: &Expression,
     filter: Option<&Expression>,
     dtype: &DType,
-) -> VortexResult<(Vec<FieldMask>, Vec<FieldMask>)> {
-    let Some(struct_dtype) = dtype.as_struct_fields_opt() else {
-        return Ok(match filter {
-            Some(_) => (vec![FieldMask::All], vec![FieldMask::All]),
-            None => (Vec::new(), vec![FieldMask::All]),
-        });
-    };
-    let projection_mask = immediate_scope_access(projection, struct_dtype);
-    Ok(match filter {
-        None => (
-            Vec::new(),
-            projection_mask.into_iter().map(to_field_mask).collect_vec(),
-        ),
-        Some(f) => {
-            let filter_mask = immediate_scope_access(f, struct_dtype);
-            let only_projection_mask = projection_mask
-                .difference(&filter_mask)
-                .cloned()
-                .map(to_field_mask)
-                .collect_vec();
-            (
-                filter_mask.into_iter().map(to_field_mask).collect_vec(),
-                only_projection_mask,
-            )
-        }
-    })
-}
+) -> VortexResult<Vec<FieldMask>> {
+    if dtype.as_struct_fields_opt().is_none() {
+        return Ok(vec![FieldMask::All]);
+    }
 
-fn to_field_mask(field: FieldName) -> FieldMask {
-    FieldMask::Prefix(FieldPath::from(Field::Name(field)))
+    let mut field_paths = referenced_field_paths(projection, dtype)?;
+    if let Some(filter) = filter {
+        field_paths.extend(referenced_field_paths(filter, dtype)?);
+    }
+    Ok(field_paths.into_iter().map(FieldMask::Prefix).collect_vec())
 }
 
 #[cfg(test)]
@@ -470,9 +446,16 @@ mod test {
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::dtype::DType;
     use vortex_array::dtype::FieldMask;
+    use vortex_array::dtype::FieldPath;
     use vortex_array::dtype::Nullability;
     use vortex_array::dtype::PType;
+    use vortex_array::dtype::StructFields;
     use vortex_array::expr::Expression;
+    use vortex_array::expr::eq;
+    use vortex_array::expr::get_item;
+    use vortex_array::expr::is_not_null;
+    use vortex_array::expr::lit;
+    use vortex_array::expr::root;
     use vortex_error::VortexResult;
     use vortex_error::vortex_err;
     use vortex_io::runtime::BlockingRuntime;
@@ -480,6 +463,7 @@ mod test {
     use vortex_mask::Mask;
 
     use super::ScanBuilder;
+    use super::referenced_field_masks;
     use crate::ArrayFuture;
     use crate::LayoutReader;
     use crate::RowSplits;
@@ -487,6 +471,60 @@ mod test {
     use crate::scan::test::SCAN_SESSION;
     use crate::scan::test::session_with_handle;
 
+    fn nested_dtype() -> DType {
+        DType::Struct(
+            StructFields::from_iter([
+                (
+                    "a",
+                    DType::Struct(
+                        StructFields::from_iter([
+                            ("1", DType::Primitive(PType::I32, Nullability::NonNullable)),
+                            ("2", DType::Primitive(PType::I32, Nullability::NonNullable)),
+                        ]),
+                        Nullability::NonNullable,
+                    ),
+                ),
+                ("b", DType::Primitive(PType::I32, Nullability::NonNullable)),
+            ]),
+            Nullability::NonNullable,
+        )
+    }
+
+    #[test]
+    fn nested_projection_preserves_field_path_in_split_mask() -> VortexResult<()> {
+        let projection = get_item("1", get_item("a", root()));
+        let filter = eq(get_item("2", get_item("a", root())), lit(0_i32));
+
+        let field_masks = referenced_field_masks(&projection, Some(&filter), &nested_dtype())?;
+
+        assert_eq!(field_masks.len(), 2);
+        assert!(field_masks.contains(&FieldMask::Prefix(FieldPath::from_name("a").push("1"))));
+        assert!(field_masks.contains(&FieldMask::Prefix(FieldPath::from_name("a").push("2"))));
+        Ok(())
+    }
+
+    #[test]
+    fn filter_path_covers_nested_projection_path() -> VortexResult<()> {
+        let projection = get_item("1", get_item("a", root()));
+        let filter = is_not_null(get_item("a", root()));
+
+        let field_masks = referenced_field_masks(&projection, Some(&filter), &nested_dtype())?;
+
+        assert_eq!(field_masks, [FieldMask::Prefix(FieldPath::from_name("a"))]);
+        Ok(())
+    }
+
+    #[test]
+    fn parent_projection_path_covers_nested_filter_path() -> VortexResult<()> {
+        let projection = get_item("a", root());
+        let filter = is_not_null(get_item("1", get_item("a", root())));
+
+        let field_masks = referenced_field_masks(&projection, Some(&filter), &nested_dtype())?;
+
+        assert_eq!(field_masks, [FieldMask::Prefix(FieldPath::from_name("a"))]);
+        Ok(())
+    }
+
     #[derive(Debug)]
     struct CountingLayoutReader {
         name: Arc<str>,
diff --git a/vortex-layout/src/scan/split_by.rs b/vortex-layout/src/scan/split_by.rs
index 34b0edbf4c8..cdaf260cdb8 100644
--- a/vortex-layout/src/scan/split_by.rs
+++ b/vortex-layout/src/scan/split_by.rs
@@ -107,7 +107,7 @@ mod test {
         .unwrap();
 
         layout
-            .new_reader("".into(), segments, &SCAN_SESSION)
+            .new_reader("".into(), segments, &SCAN_SESSION, &Default::default())
             .unwrap()
     }
 
diff --git a/vortex-layout/src/vtable.rs b/vortex-layout/src/vtable.rs
index 9bb83fcf643..c48a9d33d1f 100644
--- a/vortex-layout/src/vtable.rs
+++ b/vortex-layout/src/vtable.rs
@@ -19,6 +19,7 @@ use crate::LayoutChildType;
 use crate::LayoutEncoding;
 use crate::LayoutEncodingRef;
 use crate::LayoutId;
+use crate::LayoutReaderContext;
 use crate::LayoutReaderRef;
 use crate::LayoutRef;
 use crate::children::LayoutChildren;
@@ -58,11 +59,20 @@ pub trait VTable: 'static + Sized + Send + Sync + Debug {
     fn child_type(layout: &Self::Layout, idx: usize) -> LayoutChildType;
 
     /// Create a new reader for the layout.
+    ///
+    /// **Layouts with children MUST propagate `ctx` to descendants** by passing it
+    /// through `Layout::new_reader` (or `LazyReaderChildren::new`) when constructing
+    /// child readers. If `ctx` is dropped at any link in the chain, ancestor-published
+    /// values won't reach affected descendants — a silent runtime regression for any
+    /// descendant that looked up an ancestor-published value via `ctx.get::<T>()`.
+    /// There is no compile-time check that catches this; reviewer discipline + the
+    /// integration tests in `vortex-layout` are the only safety net.
     fn new_reader(
         layout: &Self::Layout,
         name: Arc<str>,
         segment_source: Arc<dyn SegmentSource>,
         session: &VortexSession,
+        ctx: &LayoutReaderContext,
     ) -> VortexResult<LayoutReaderRef>;
 
     /// Construct a new [`Layout`] from the provided parts.
diff --git a/vortex-mask/Cargo.toml b/vortex-mask/Cargo.toml
index a2af3d27cb0..7aa5bb2ef85 100644
--- a/vortex-mask/Cargo.toml
+++ b/vortex-mask/Cargo.toml
@@ -14,14 +14,12 @@ rust-version = { workspace = true }
 version = { workspace = true }
 
 [features]
-arrow = ["dep:arrow-buffer"]
 serde = ["dep:serde", "vortex-buffer/serde"]
 
 [package.metadata.docs.rs]
 all-features = true
 
 [dependencies]
-arrow-buffer = { workspace = true, optional = true }
 itertools = { workspace = true }
 serde = { workspace = true, optional = true, features = ["rc"] }
 vortex-buffer = { workspace = true, features = ["arrow"] }
diff --git a/vortex-mask/src/bitops.rs b/vortex-mask/src/bitops.rs
index 94d7ef02980..4bebcf28c40 100644
--- a/vortex-mask/src/bitops.rs
+++ b/vortex-mask/src/bitops.rs
@@ -28,6 +28,26 @@ impl BitAnd for &Mask {
     }
 }
 
+impl BitAnd<&Mask> for Mask {
+    type Output = Mask;
+
+    /// Owned-left AND: can reuse the left buffer in-place when possible.
+    fn bitand(self, rhs: &Mask) -> Self::Output {
+        if self.len() != rhs.len() {
+            vortex_panic!("Masks must have the same length");
+        }
+
+        match (self.bit_buffer(), rhs.bit_buffer()) {
+            (AllOr::All, _) => rhs.clone(),
+            (AllOr::None, _) | (_, AllOr::None) => Mask::new_false(self.len()),
+            (_, AllOr::All) => self,
+            (AllOr::Some(_), AllOr::Some(rhs_buf)) => {
+                Mask::from_buffer(self.into_bit_buffer() & rhs_buf)
+            }
+        }
+    }
+}
+
 impl BitOr for &Mask {
     type Output = Mask;
 
@@ -46,6 +66,26 @@ impl BitOr for &Mask {
     }
 }
 
+impl BitOr<&Mask> for Mask {
+    type Output = Mask;
+
+    /// Owned-left OR: can reuse the left buffer in-place when possible.
+    fn bitor(self, rhs: &Mask) -> Self::Output {
+        if self.len() != rhs.len() {
+            vortex_panic!("Masks must have the same length");
+        }
+
+        match (self.bit_buffer(), rhs.bit_buffer()) {
+            (AllOr::All, _) | (_, AllOr::All) => Mask::new_true(self.len()),
+            (AllOr::None, _) => rhs.clone(),
+            (_, AllOr::None) => self,
+            (AllOr::Some(_), AllOr::Some(rhs_buf)) => {
+                Mask::from_buffer(self.into_bit_buffer() | rhs_buf)
+            }
+        }
+    }
+}
+
 impl Mask {
     /// Computes `self & !rhs` (AND NOT), equivalent to set difference.
     pub fn bitand_not(self, rhs: &Mask) -> Mask {
@@ -56,7 +96,9 @@ impl Mask {
             (AllOr::None, _) | (_, AllOr::All) => Mask::new_false(self.len()),
             (_, AllOr::None) => self,
             (AllOr::All, _) => !rhs,
-            (AllOr::Some(lhs), AllOr::Some(rhs)) => Mask::from_buffer(lhs.bitand_not(rhs)),
+            (AllOr::Some(_), AllOr::Some(rhs_buf)) => {
+                Mask::from_buffer(self.into_bit_buffer().into_bitand_not(rhs_buf))
+            }
         }
     }
 }
diff --git a/vortex-mask/src/eq.rs b/vortex-mask/src/eq.rs
index 5cf1ff640df..6e43df8388f 100644
--- a/vortex-mask/src/eq.rs
+++ b/vortex-mask/src/eq.rs
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::mem;
+
 use crate::Mask;
 
 impl PartialEq for Mask {
@@ -9,6 +11,9 @@ impl PartialEq for Mask {
         if self.len() != other.len() {
             return false;
         }
+        if mem::discriminant(self) == mem::discriminant(other) && !matches!(self, Mask::Values(_)) {
+            return true;
+        }
         if self.true_count() != other.true_count() {
             return false;
         }
diff --git a/vortex-mask/src/lib.rs b/vortex-mask/src/lib.rs
index 41901ba2ba3..401077f0b34 100644
--- a/vortex-mask/src/lib.rs
+++ b/vortex-mask/src/lib.rs
@@ -22,6 +22,7 @@ use std::sync::OnceLock;
 use itertools::Itertools;
 use vortex_buffer::BitBuffer;
 use vortex_buffer::BitBufferMut;
+use vortex_buffer::BitIterator;
 use vortex_error::VortexResult;
 use vortex_error::vortex_panic;
 
@@ -428,6 +429,26 @@ impl Mask {
         }
     }
 
+    /// Iterate the mask as one `bool` per element, in order.
+    ///
+    /// Unlike repeatedly calling [`Mask::value`], this advances a single cursor rather than
+    /// recomputing the byte/bit offset for every element, and it does not allocate for the
+    /// all-true / all-false variants. Prefer this for sequential per-element scans.
+    #[inline]
+    pub fn iter(&self) -> MaskBoolIter<'_> {
+        match self {
+            Mask::AllTrue(len) => MaskBoolIter::Repeat {
+                value: true,
+                remaining: *len,
+            },
+            Mask::AllFalse(len) => MaskBoolIter::Repeat {
+                value: false,
+                remaining: *len,
+            },
+            Mask::Values(values) => MaskBoolIter::Bits(values.bit_buffer().iter()),
+        }
+    }
+
     /// Returns the first true index in the mask.
     pub fn first(&self) -> Option<usize> {
         match &self {
@@ -814,6 +835,48 @@ pub enum MaskIter<'a> {
     Slices(&'a [(usize, usize)]),
 }
 
+/// Iterator yielding one `bool` per element of a [`Mask`], in order.
+///
+/// Created by [`Mask::iter`].
+pub enum MaskBoolIter<'a> {
+    /// An all-true or all-false run.
+    Repeat {
+        /// The constant value yielded by every element of the run.
+        value: bool,
+        /// The number of elements still to yield.
+        remaining: usize,
+    },
+    /// Per-element bits of a [`Mask::Values`] mask.
+    Bits(BitIterator<'a>),
+}
+
+impl Iterator for MaskBoolIter<'_> {
+    type Item = bool;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        match self {
+            Self::Repeat { remaining: 0, .. } => None,
+            Self::Repeat { value, remaining } => {
+                *remaining -= 1;
+                Some(*value)
+            }
+            Self::Bits(bits) => bits.next(),
+        }
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let remaining = match self {
+            Self::Repeat { remaining, .. } => *remaining,
+            Self::Bits(bits) => bits.len(),
+        };
+        (remaining, Some(remaining))
+    }
+}
+
+impl ExactSizeIterator for MaskBoolIter<'_> {}
+
 impl From<BitBuffer> for Mask {
     fn from(value: BitBuffer) -> Self {
         Self::from_buffer(value)
diff --git a/vortex-mask/src/tests.rs b/vortex-mask/src/tests.rs
index 65687afef15..c1a4928f548 100644
--- a/vortex-mask/src/tests.rs
+++ b/vortex-mask/src/tests.rs
@@ -725,3 +725,29 @@ fn test_mask_concat_mixed_types() {
     assert!(!result.value(6)); // from all_false
     assert!(!result.value(7)); // from all_false
 }
+
+// `Mask::iter` per-element bool iteration
+
+#[rstest]
+#[case::all_true(Mask::new_true(4), vec![true, true, true, true])]
+#[case::all_false(Mask::new_false(3), vec![false, false, false])]
+#[case::values(
+    Mask::from_buffer(BitBuffer::from_iter([true, false, true, true, false])),
+    vec![true, false, true, true, false]
+)]
+#[case::empty(Mask::new_true(0), vec![])]
+fn mask_iter_matches_value(#[case] mask: Mask, #[case] expected: Vec<bool>) {
+    // Iterator yields exactly one bool per element, matching `value`.
+    let collected: Vec<bool> = mask.iter().collect();
+    assert_eq!(collected, expected);
+
+    let by_value: Vec<bool> = (0..mask.len()).map(|i| mask.value(i)).collect();
+    assert_eq!(collected, by_value);
+
+    // ExactSizeIterator reports the right length, including after partial consumption.
+    let mut it = mask.iter();
+    assert_eq!(it.len(), mask.len());
+    if it.next().is_some() {
+        assert_eq!(it.len(), mask.len() - 1);
+    }
+}
diff --git a/vortex-python/src/arrays/py/vtable.rs b/vortex-python/src/arrays/py/vtable.rs
index 9e1461f3c51..f8c8f44d7f8 100644
--- a/vortex-python/src/arrays/py/vtable.rs
+++ b/vortex-python/src/arrays/py/vtable.rs
@@ -11,10 +11,10 @@ use vortex::array::ArrayId;
 use vortex::array::ArrayParts;
 use vortex::array::ArrayRef;
 use vortex::array::ArrayView;
+use vortex::array::EqMode;
 use vortex::array::ExecutionCtx;
 use vortex::array::ExecutionResult;
 use vortex::array::OperationsVTable;
-use vortex::array::Precision;
 use vortex::array::VTable;
 use vortex::array::ValidityVTable;
 use vortex::array::buffer::BufferHandle;
@@ -37,13 +37,13 @@ pub struct PythonVTable {
 }
 
 impl ArrayHash for PythonArray {
-    fn array_hash<H: std::hash::Hasher>(&self, state: &mut H, _precision: Precision) {
+    fn array_hash<H: std::hash::Hasher>(&self, state: &mut H, _accuracy: EqMode) {
         Arc::as_ptr(&self.object).hash(state);
     }
 }
 
 impl ArrayEq for PythonArray {
-    fn array_eq(&self, other: &Self, _precision: Precision) -> bool {
+    fn array_eq(&self, other: &Self, _accuracy: EqMode) -> bool {
         Arc::ptr_eq(&self.object, &other.object)
     }
 }
diff --git a/vortex-python/src/object_store/resolve.rs b/vortex-python/src/object_store/resolve.rs
index 4ec6d321601..4b4943bb9c6 100644
--- a/vortex-python/src/object_store/resolve.rs
+++ b/vortex-python/src/object_store/resolve.rs
@@ -11,6 +11,7 @@ use object_store::registry::ObjectStoreRegistry;
 use url::Url;
 use vortex::error::VortexResult;
 use vortex::error::vortex_err;
+use vortex::io::compat::Compat;
 
 use crate::object_store::registry::Registry;
 
@@ -29,7 +30,7 @@ pub(crate) fn resolve_store(
 ) -> VortexResult<ResolvedStore> {
     match store {
         // If explicit store is provided use that
-        Some(store) => Ok(ResolvedStore::ObjectStore(store, Path::from(url_or_path))),
+        Some(store) => Ok(ResolvedStore::object_store(store, Path::from(url_or_path))),
         None => {
             // If the URL does not parse
             match Url::parse(url_or_path) {
@@ -41,7 +42,7 @@ pub(crate) fn resolve_store(
                 }
                 Ok(url) => {
                     let (store, path) = REGISTRY.resolve(&url)?;
-                    Ok(ResolvedStore::ObjectStore(store, path))
+                    Ok(ResolvedStore::object_store(store, path))
                 }
                 Err(_) => {
                     // Treat the input string as a local file system path, which may be
@@ -59,6 +60,12 @@ pub(crate) enum ResolvedStore {
 }
 
 impl ResolvedStore {
+    /// Build an [`ObjectStore`](ResolvedStore::ObjectStore) variant, wrapping `store` in
+    /// [`Compat`].
+    fn object_store(store: Arc<dyn ObjectStore>, path: Path) -> Self {
+        ResolvedStore::ObjectStore(Arc::new(Compat::new(store)), path)
+    }
+
     #[cfg(test)]
     fn unwrap_store(self) -> (Arc<dyn ObjectStore>, Path) {
         match self {
diff --git a/vortex-turboquant/Cargo.toml b/vortex-row/Cargo.toml
similarity index 64%
rename from vortex-turboquant/Cargo.toml
rename to vortex-row/Cargo.toml
index ab3f63583d3..9222c7d6a43 100644
--- a/vortex-turboquant/Cargo.toml
+++ b/vortex-row/Cargo.toml
@@ -1,13 +1,14 @@
 [package]
-name = "vortex-turboquant"
+name = "vortex-row"
 authors = { workspace = true }
 categories = { workspace = true }
-description = "TurboQuant vector extension type"
+description = "Row-oriented byte encoder for Vortex arrays, analogous to arrow-row."
 edition = { workspace = true }
 homepage = { workspace = true }
 include = { workspace = true }
 keywords = { workspace = true }
 license = { workspace = true }
+publish = false
 readme = { workspace = true }
 repository = { workspace = true }
 rust-version = { workspace = true }
@@ -17,25 +18,24 @@ version = { workspace = true }
 workspace = true
 
 [dependencies]
-half = { workspace = true }
-num-traits = { workspace = true }
-prost = { workspace = true }
+bytes = { workspace = true }
+smallvec = { workspace = true }
 vortex-array = { workspace = true }
 vortex-buffer = { workspace = true }
 vortex-error = { workspace = true }
 vortex-mask = { workspace = true }
 vortex-session = { workspace = true }
-vortex-tensor = { workspace = true }
-vortex-utils = { workspace = true, features = ["dashmap"] }
 
 [dev-dependencies]
+arrow-array = { workspace = true }
+arrow-row = { workspace = true }
+arrow-schema = { workspace = true }
 divan = { workspace = true }
+mimalloc = { workspace = true }
 rand = { workspace = true }
 rstest = { workspace = true }
-vortex-file = { workspace = true }
-vortex-io = { workspace = true }
-vortex-layout = { workspace = true }
+vortex-array = { workspace = true, features = ["_test-harness"] }
 
 [[bench]]
-name = "encode_decode"
+name = "row_encode"
 harness = false
diff --git a/vortex-row/README.md b/vortex-row/README.md
new file mode 100644
index 00000000000..e0c574eca43
--- /dev/null
+++ b/vortex-row/README.md
@@ -0,0 +1,17 @@
+# vortex-row
+
+`vortex-row` provides an experimental row-oriented byte encoder for Vortex arrays. It
+produces byte strings that can be compared lexicographically to sort rows according to the
+configured column ordering.
+
+Only supported Vortex logical types are accepted. Extension types are rejected until their
+logical sort semantics are defined.
+
+## Experimental Format
+
+The row encoding byte layout is experimental. Its exact bytes, supported type set, and
+edge-case semantics may change between Vortex releases.
+
+Do not persist row-encoded bytes or use them as a stable interchange format. They are intended
+for internal sort-key and row-key operations where the encoder version, schema, and sort
+options are controlled together.
diff --git a/vortex-row/benches/row_encode.rs b/vortex-row/benches/row_encode.rs
new file mode 100644
index 00000000000..729b992d8e1
--- /dev/null
+++ b/vortex-row/benches/row_encode.rs
@@ -0,0 +1,181 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![expect(
+    clippy::unwrap_used,
+    clippy::clone_on_ref_ptr,
+    clippy::cloned_ref_to_slice_refs,
+    clippy::redundant_clone
+)]
+
+//! Row-encode throughput benchmarks comparing `arrow-row` against Vortex's [`RowEncoder`]
+//! for the core canonical scenarios: a primitive i64 column, a Utf8 column, and a
+//! mixed-field struct.
+
+use std::sync::Arc;
+use std::sync::LazyLock;
+
+use arrow_array::Int64Array;
+use arrow_array::StringArray;
+use arrow_array::StructArray as ArrowStructArray;
+use arrow_row::RowConverter;
+use arrow_row::SortField as ArrowSortField;
+use arrow_schema::DataType;
+use arrow_schema::Field;
+use divan::counter::BytesCount;
+use mimalloc::MiMalloc;
+use rand::RngExt;
+use rand::SeedableRng;
+use rand::distr::Alphanumeric;
+use rand::rngs::StdRng;
+use vortex_array::IntoArray;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::StructArray;
+use vortex_array::arrays::VarBinViewArray;
+use vortex_array::session::ArraySession;
+use vortex_row::RowEncoder;
+use vortex_session::VortexSession;
+
+#[global_allocator]
+static GLOBAL: MiMalloc = MiMalloc;
+
+const N: usize = 100_000;
+
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
+fn main() {
+    divan::main();
+}
+
+fn gen_i64(n: usize, seed: u64) -> Vec<i64> {
+    let mut rng = StdRng::seed_from_u64(seed);
+    (0..n)
+        .map(|_| rng.random_range(i64::MIN..i64::MAX))
+        .collect()
+}
+
+fn gen_words(n: usize, mean_len: usize, seed: u64) -> Vec<String> {
+    let rng = &mut StdRng::seed_from_u64(seed);
+    (0..n)
+        .map(|_| {
+            let len = rng.random_range(mean_len.saturating_sub(4)..=mean_len + 4);
+            rng.sample_iter(&Alphanumeric)
+                .take(len)
+                .map(char::from)
+                .collect::<String>()
+        })
+        .collect()
+}
+
+// ---------- primitive_i64 ----------
+
+#[divan::bench]
+fn primitive_i64_arrow_row(bencher: divan::Bencher) {
+    let v = gen_i64(N, 0);
+    let arr = Arc::new(Int64Array::from(v.clone())) as arrow_array::ArrayRef;
+    let conv = RowConverter::new(vec![ArrowSortField::new(DataType::Int64)]).unwrap();
+    let bytes = (N * (1 + 8)) as u64;
+    bencher
+        .counter(BytesCount::new(bytes))
+        .bench_local(|| conv.convert_columns(&[arr.clone()]).unwrap())
+}
+
+#[divan::bench]
+fn primitive_i64_vortex(bencher: divan::Bencher) {
+    let v = gen_i64(N, 0);
+    let col = PrimitiveArray::from_iter(v.clone()).into_array();
+    let bytes = (N * (1 + 8)) as u64;
+    let encoder = RowEncoder::default();
+    bencher
+        .counter(BytesCount::new(bytes))
+        .with_inputs(|| SESSION.create_execution_ctx())
+        .bench_local_values(|mut ctx| encoder.encode(&[col.clone()], &mut ctx).unwrap())
+}
+
+// ---------- utf8 ----------
+
+#[divan::bench]
+fn utf8_arrow_row(bencher: divan::Bencher) {
+    let words = gen_words(N, 16, 7);
+    let total: u64 = words
+        .iter()
+        .map(|w| 1 + (w.len().div_ceil(32) * 33) as u64)
+        .sum();
+    let arr = Arc::new(StringArray::from(words.clone())) as arrow_array::ArrayRef;
+    let conv = RowConverter::new(vec![ArrowSortField::new(DataType::Utf8)]).unwrap();
+    bencher
+        .counter(BytesCount::new(total))
+        .bench_local(|| conv.convert_columns(&[arr.clone()]).unwrap())
+}
+
+#[divan::bench]
+fn utf8_vortex(bencher: divan::Bencher) {
+    let words = gen_words(N, 16, 7);
+    let total: u64 = words
+        .iter()
+        .map(|w| 1 + (w.len().div_ceil(32) * 33) as u64)
+        .sum();
+    let col = VarBinViewArray::from_iter_str(words.iter().map(String::as_str)).into_array();
+    let encoder = RowEncoder::default();
+    bencher
+        .counter(BytesCount::new(total))
+        .with_inputs(|| SESSION.create_execution_ctx())
+        .bench_local_values(|mut ctx| encoder.encode(&[col.clone()], &mut ctx).unwrap())
+}
+
+// ---------- struct_mixed ----------
+
+fn struct_mixed_inputs() -> (Vec<i64>, Vec<String>, u64) {
+    let ids = gen_i64(N, 1);
+    let names = gen_words(N, 16, 2);
+    // sentinel (1) + i64 (1+8=9) + utf8-name (1 + ceil(len/32)*33)
+    let total: u64 = (0..N)
+        .map(|i| {
+            let name_bytes = 1 + (names[i].len().div_ceil(32) * 33) as u64;
+            1u64 + 9u64 + name_bytes
+        })
+        .sum();
+    (ids, names, total)
+}
+
+#[divan::bench]
+fn struct_mixed_arrow_row(bencher: divan::Bencher) {
+    let (ids, names, total) = struct_mixed_inputs();
+    let id_arr = Arc::new(Int64Array::from(ids)) as arrow_array::ArrayRef;
+    let name_arr = Arc::new(StringArray::from(names)) as arrow_array::ArrayRef;
+    let arrow_struct = Arc::new(ArrowStructArray::from(vec![
+        (Arc::new(Field::new("id", DataType::Int64, false)), id_arr),
+        (
+            Arc::new(Field::new("name", DataType::Utf8, false)),
+            name_arr,
+        ),
+    ])) as arrow_array::ArrayRef;
+    let struct_fields = vec![
+        Arc::new(Field::new("id", DataType::Int64, false)),
+        Arc::new(Field::new("name", DataType::Utf8, false)),
+    ];
+    let conv = RowConverter::new(vec![ArrowSortField::new(DataType::Struct(
+        struct_fields.into(),
+    ))])
+    .unwrap();
+    bencher
+        .counter(BytesCount::new(total))
+        .bench_local(|| conv.convert_columns(&[arrow_struct.clone()]).unwrap())
+}
+
+#[divan::bench]
+fn struct_mixed_vortex(bencher: divan::Bencher) {
+    let (ids, names, total) = struct_mixed_inputs();
+    let id_arr = PrimitiveArray::from_iter(ids).into_array();
+    let name_arr = VarBinViewArray::from_iter_str(names.iter().map(String::as_str)).into_array();
+    let struct_arr = StructArray::from_fields(&[("id", id_arr), ("name", name_arr)])
+        .unwrap()
+        .into_array();
+    let encoder = RowEncoder::default();
+    bencher
+        .counter(BytesCount::new(total))
+        .with_inputs(|| SESSION.create_execution_ctx())
+        .bench_local_values(|mut ctx| encoder.encode(&[struct_arr.clone()], &mut ctx).unwrap())
+}
diff --git a/vortex-row/src/codec.rs b/vortex-row/src/codec.rs
new file mode 100644
index 00000000000..4848a750e52
--- /dev/null
+++ b/vortex-row/src/codec.rs
@@ -0,0 +1,1257 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Pure byte-encoding kernels for row-oriented output, operating on `Canonical` variants.
+//!
+//! The encoded byte format produces a lexicographically byte-comparable representation:
+//! comparing the byte slices of two encoded rows yields the same ordering as the
+//! original logical (tuple) comparison of their values, modulo nulls placement and
+//! descending-ness as configured by [`RowSortField`].
+//!
+//! Conventions:
+//! - Every fixed-width value is preceded by a 1-byte sentinel that orders nulls relative to
+//!   non-nulls. For `descending`, only the **value** bytes are bit-inverted (XOR with 0xFF),
+//!   not the sentinel.
+//! - Variable-length (Utf8, Binary) values use **three** distinct leading sentinels — one each
+//!   for null, empty, and non-empty — so byte comparison at position 0 fully categorizes the
+//!   value and column-byte boundaries stay aligned across rows. See
+//!   [`varlen_null_sentinel`], [`varlen_empty_sentinel`], [`varlen_non_empty_sentinel`].
+//! - Fixed-width integers are big-endian, with the sign bit flipped for signed types.
+//! - Floats are bit-pattern big-endian with sign-aware mask: non-negative flips the top
+//!   bit; negative flips all bits.
+//! - Nullable structs and fixed-size lists encode null parent rows with a **canonical null
+//!   body** so two null parent rows produce byte-equal encodings: fixed-width children
+//!   contribute their fixed null encoding, and variable-width children collapse to a single
+//!   null sentinel byte.
+
+use vortex_array::Canonical;
+use vortex_array::ExecutionCtx;
+use vortex_array::arrays::BoolArray;
+use vortex_array::arrays::DecimalArray;
+use vortex_array::arrays::FixedSizeListArray;
+use vortex_array::arrays::NullArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::StructArray;
+use vortex_array::arrays::VarBinViewArray;
+use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
+use vortex_array::arrays::struct_::StructArrayExt;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::DecimalType;
+use vortex_array::dtype::NativePType;
+use vortex_array::dtype::half::f16;
+use vortex_array::match_each_native_ptype;
+use vortex_array::validity::Validity;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+
+use crate::options::RowSortField;
+
+/// Size in bytes of the encoded form of a single bool value (sentinel + 1 content byte).
+pub(crate) const BOOL_ENCODED_SIZE: u32 = 2;
+
+/// Block size used in the variable-length encoding.
+pub(crate) const VARLEN_BLOCK_SIZE: usize = 32;
+/// Total bytes per varlen block including the trailing continuation marker.
+pub(crate) const VARLEN_BLOCK_TOTAL: usize = VARLEN_BLOCK_SIZE + 1;
+const VARLEN_BLOCK_TOTAL_U32: u32 = 33;
+
+/// Size in bytes of an encoded null varlen value (just the sentinel byte).
+pub(crate) const VARLEN_NULL_SIZE: u32 = 1;
+/// Size in bytes of an encoded empty varlen value (just the sentinel byte).
+pub(crate) const VARLEN_EMPTY_SIZE: u32 = 1;
+
+/// Returns the size in bytes of the encoded form of a non-empty variable-length value.
+///
+/// Includes the leading sentinel byte plus `ceil(len/32) * 33` block bytes (32 content + 1
+/// continuation/length byte). Callers must use [`VARLEN_NULL_SIZE`] for null values and
+/// [`VARLEN_EMPTY_SIZE`] for empty values. A `u32` always suffices because a `BinaryView`
+/// length is itself a `u32`, so `blocks <= ceil(u32::MAX / 32) < 2^27`.
+#[inline]
+fn encoded_size_for_non_empty_varlen(len: usize) -> u32 {
+    debug_assert!(len > 0);
+    let blocks = u32::try_from(len.div_ceil(VARLEN_BLOCK_SIZE))
+        .vortex_expect("varlen block count must fit in u32");
+    1 + blocks * VARLEN_BLOCK_TOTAL_U32
+}
+
+/// Constant per-row size in bytes for fixed-width encodings (including 1-byte sentinel).
+#[inline]
+const fn encoded_size_for_fixed(value_bytes: u32) -> u32 {
+    1 + value_bytes
+}
+
+fn byte_width_u32(width: usize) -> u32 {
+    u32::try_from(width).vortex_expect("native byte width must fit in u32")
+}
+
+/// Pre-resolved per-row validity for the row encoders.
+///
+/// Encoders pattern-match on this once before their inner loop so the no-nulls fast path
+/// avoids per-row `mask.value(i)` branches entirely, and the nullable path materializes the
+/// mask exactly once.
+pub(crate) enum ValidityKind {
+    /// Column statically has no nulls (`Validity::NonNullable` or `AllValid`); no mask needed.
+    AllValid,
+    /// Column may have nulls; carries the materialized per-row mask.
+    Mask(vortex_mask::Mask),
+}
+
+/// Resolve a [`Validity`] into a [`ValidityKind`], materializing the mask only when the column
+/// may actually have nulls.
+#[inline]
+pub(crate) fn resolve_validity(
+    validity: Validity,
+    len: usize,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ValidityKind> {
+    Ok(match validity {
+        Validity::NonNullable | Validity::AllValid => ValidityKind::AllValid,
+        other => ValidityKind::Mask(other.execute_mask(len, ctx)?),
+    })
+}
+
+/// Returns the sentinel byte for a null varlen value.
+///
+/// The choice is positional (0x00 when nulls sort first, 0xFF when nulls sort last) and
+/// independent of `descending`, matching the convention used by `arrow-row`.
+#[inline]
+fn varlen_null_sentinel(field: RowSortField) -> u8 {
+    if field.nulls_first { 0x00 } else { 0xFF }
+}
+
+/// Returns the sentinel byte for an empty varlen value.
+///
+/// Equal to `0x01` in ascending mode and `!0x01 = 0xFE` in descending mode.
+#[inline]
+fn varlen_empty_sentinel(field: RowSortField) -> u8 {
+    if field.descending { !0x01u8 } else { 0x01u8 }
+}
+
+/// Returns the sentinel byte for a non-empty varlen value.
+///
+/// Equal to `0x02` in ascending mode and `!0x02 = 0xFD` in descending mode.
+#[inline]
+fn varlen_non_empty_sentinel(field: RowSortField) -> u8 {
+    if field.descending { !0x02u8 } else { 0x02u8 }
+}
+
+/// Returns the single-byte null sentinel used when a child contributes its canonical null
+/// encoding inside a null parent struct/FSL row.
+///
+/// For varlen children that is the varlen null sentinel; for everything else (including
+/// nested struct/FSL when used as a variable-width child) it is the fixed-width null sentinel.
+fn child_canonical_null_byte(child_dtype: &DType, field: RowSortField) -> u8 {
+    match child_dtype {
+        DType::Utf8(_) | DType::Binary(_) => varlen_null_sentinel(field),
+        _ => field.null_sentinel(),
+    }
+}
+
+/// Per-row width classification for a column.
+///
+/// `Fixed(w)` means every row encodes to exactly `w` bytes (sentinel + value), regardless
+/// of null-ness or value. `Variable` means per-row sizes depend on the data (Utf8/Binary,
+/// List, or any composite that recurses through a variable-width field).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum RowWidth {
+    /// Per-row width is the same constant for every row in the column.
+    Fixed(u32),
+    /// Per-row width is data-dependent.
+    Variable,
+}
+
+/// Classify a column's per-row encoded width by inspecting only its [`DType`].
+///
+/// Returns `Fixed(w)` when every row encodes to exactly `w` bytes (sentinel + value),
+/// regardless of null-ness or value. Returns `Variable` when per-row sizes depend on the
+/// data.
+///
+/// Classification does not depend on the [`RowSortField`]: null-vs-non-null encoding width is
+/// the same for fixed-width types (the sentinel byte plus zero-fill for nulls).
+///
+/// # Errors
+///
+/// Returns an error for dtypes that the row encoder does not support. Width arithmetic that
+/// would overflow `u32` is also reported as an error rather than silently saturating.
+pub(crate) fn row_width_for_dtype(dtype: &DType) -> VortexResult<RowWidth> {
+    match dtype {
+        DType::Null => Ok(RowWidth::Fixed(1)),
+        DType::Bool(_) => Ok(RowWidth::Fixed(BOOL_ENCODED_SIZE)),
+        DType::Primitive(ptype, _) => Ok(RowWidth::Fixed(encoded_size_for_fixed(byte_width_u32(
+            ptype.byte_width(),
+        )))),
+        DType::Decimal(dt, _) => {
+            let vt = DecimalType::smallest_decimal_value_type(dt);
+            if matches!(vt, DecimalType::I256) {
+                vortex_bail!("row encoding for Decimal256 is not yet implemented");
+            }
+            Ok(RowWidth::Fixed(encoded_size_for_fixed(byte_width_u32(
+                vt.byte_width(),
+            ))))
+        }
+        DType::Utf8(_) | DType::Binary(_) => Ok(RowWidth::Variable),
+        DType::FixedSizeList(elem, n, _) => match row_width_for_dtype(elem)? {
+            // FSL is fixed iff its element type is fixed. Add a sentinel byte for the FSL
+            // itself, then `n` copies of the element width.
+            RowWidth::Fixed(w) => {
+                let body = w
+                    .checked_mul(*n)
+                    .ok_or_else(|| vortex_error::vortex_err!("FSL row width overflows u32"))?;
+                let total = body
+                    .checked_add(1)
+                    .ok_or_else(|| vortex_error::vortex_err!("FSL row width overflows u32"))?;
+                Ok(RowWidth::Fixed(total))
+            }
+            RowWidth::Variable => Ok(RowWidth::Variable),
+        },
+        DType::Struct(fields, _) => {
+            // Struct is fixed iff all its fields are fixed; sum their widths plus a sentinel.
+            let mut total: u32 = 1; // outer sentinel
+            for field_dtype in fields.fields() {
+                match row_width_for_dtype(&field_dtype)? {
+                    RowWidth::Fixed(w) => {
+                        total = total.checked_add(w).ok_or_else(|| {
+                            vortex_error::vortex_err!("Struct row width overflows u32")
+                        })?;
+                    }
+                    RowWidth::Variable => return Ok(RowWidth::Variable),
+                }
+            }
+            Ok(RowWidth::Fixed(total))
+        }
+        DType::List(..) => {
+            vortex_bail!(
+                "row encoding does not support variable-size List arrays (no well-defined ordering)"
+            )
+        }
+        DType::Variant(_) => {
+            vortex_bail!("row encoding does not support Variant arrays (no well-defined ordering)")
+        }
+        DType::Union(_) => vortex_bail!("row encoding does not support Union arrays"),
+        dtype => vortex_bail!("row encoding does not support dtype: {dtype:?}"),
+    }
+}
+
+/// Compute the per-row size in bytes for the given canonical view, adding into `sizes`.
+///
+/// `sizes` is expected to be initialized (typically zeroed). This function *adds* the
+/// per-row size to each entry so multiple columns can accumulate into the same buffer.
+///
+/// # Errors
+///
+/// Returns an error for unsupported canonical variants.
+pub(crate) fn field_size(
+    canonical: &Canonical,
+    field: RowSortField,
+    sizes: &mut [u32],
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<()> {
+    match canonical {
+        Canonical::Null(arr) => add_size_null(arr, sizes),
+        Canonical::Bool(_) => add_size_const(sizes, encoded_size_for_fixed(1)),
+        Canonical::Primitive(arr) => add_size_primitive(arr, sizes),
+        Canonical::Decimal(arr) => add_size_decimal(arr, sizes),
+        Canonical::VarBinView(arr) => add_size_varbinview(arr, sizes, ctx)?,
+        Canonical::Struct(arr) => add_size_struct(arr, field, sizes, ctx)?,
+        Canonical::FixedSizeList(arr) => add_size_fsl(arr, field, sizes, ctx)?,
+        Canonical::List(_) => vortex_bail!(
+            "row encoding does not support canonical List arrays: {:?}",
+            canonical.dtype()
+        ),
+        Canonical::Variant(_) => {
+            vortex_bail!("row encoding does not support Variant arrays (no well-defined ordering)")
+        }
+        unsupported => {
+            vortex_bail!(
+                "row encoding does not support canonical array: {:?}",
+                unsupported.dtype()
+            )
+        }
+    }
+    Ok(())
+}
+
+/// Encode a fixed-width column at arithmetic offsets, without reading or writing any per-row
+/// cursor.
+///
+/// For row `i`, the column's bytes are written starting at `i * row_stride + col_prefix
+/// (+ var_prefix[i])`, where `var_prefix` is the exclusive prefix sum of the varlen
+/// contributions (`None` when the row layout has no variable-length columns). This is the
+/// fast path for fixed-width columns that appear before any varlen column, so their
+/// within-row position is a constant offset rather than a running cursor.
+///
+/// For primitive columns in the pure-fixed case it uses a `chunks_exact_mut` hot loop that
+/// removes the per-row offset/cursor indirection (matching `arrow-row`'s `encode_not_null`).
+/// All other types reuse [`field_encode`] at the materialized offsets, so the bytes written
+/// are byte-identical to the cursor path.
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn field_encode_fixed_arithmetic(
+    canonical: &Canonical,
+    field: RowSortField,
+    col_prefix: u32,
+    row_stride: u32,
+    var_prefix: Option<&[u32]>,
+    nrows: usize,
+    out: &mut [u8],
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<()> {
+    if var_prefix.is_none()
+        && let Canonical::Primitive(arr) = canonical
+    {
+        return encode_primitive_arith(arr, field, col_prefix, row_stride, out, ctx);
+    }
+
+    // General path: materialize this column's per-row start offsets and reuse the cursor
+    // encoder with zero-initialized cursors, so every row is written at its arithmetic
+    // offset with the exact same bytes the cursor path would produce.
+    let mut offsets: Vec<u32> = Vec::with_capacity(nrows);
+    let mut base = col_prefix;
+    match var_prefix {
+        None => {
+            for _ in 0..nrows {
+                offsets.push(base);
+                base = base.wrapping_add(row_stride);
+            }
+        }
+        Some(vp) => {
+            for &p in vp.iter().take(nrows) {
+                offsets.push(base.wrapping_add(p));
+                base = base.wrapping_add(row_stride);
+            }
+        }
+    }
+    let mut cursors = vec![0u32; nrows];
+    field_encode(canonical, field, &offsets, &mut cursors, out, ctx)
+}
+
+/// Encode each row's bytes for the given canonical view into `out`, writing starting at
+/// `offsets[i] + cursors[i]` for row `i` and advancing `cursors[i]` by the number of
+/// bytes written.
+///
+/// After this call returns successfully, `cursors[i]` will have advanced by exactly the
+/// per-row contribution previously computed by [`field_size`] for the same column.
+pub(crate) fn field_encode(
+    canonical: &Canonical,
+    field: RowSortField,
+    offsets: &[u32],
+    cursors: &mut [u32],
+    out: &mut [u8],
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<()> {
+    match canonical {
+        Canonical::Null(arr) => encode_null(arr, field, offsets, cursors, out),
+        Canonical::Bool(arr) => encode_bool(arr, field, offsets, cursors, out, ctx)?,
+        Canonical::Primitive(arr) => encode_primitive(arr, field, offsets, cursors, out, ctx)?,
+        Canonical::Decimal(arr) => encode_decimal(arr, field, offsets, cursors, out, ctx)?,
+        Canonical::VarBinView(arr) => encode_varbinview(arr, field, offsets, cursors, out, ctx)?,
+        Canonical::Struct(arr) => encode_struct(arr, field, offsets, cursors, out, ctx)?,
+        Canonical::FixedSizeList(arr) => encode_fsl(arr, field, offsets, cursors, out, ctx)?,
+        Canonical::List(_) => vortex_bail!(
+            "row encoding does not support canonical List arrays: {:?}",
+            canonical.dtype()
+        ),
+        Canonical::Variant(_) => {
+            vortex_bail!("row encoding does not support Variant arrays (no well-defined ordering)")
+        }
+        unsupported => {
+            vortex_bail!(
+                "row encoding does not support canonical array: {:?}",
+                unsupported.dtype()
+            )
+        }
+    }
+    Ok(())
+}
+
+fn add_size_const(sizes: &mut [u32], add: u32) {
+    for s in sizes.iter_mut() {
+        *s += add;
+    }
+}
+
+fn add_size_null(arr: &NullArray, sizes: &mut [u32]) {
+    debug_assert_eq!(arr.len(), sizes.len());
+    // Just a sentinel byte per row.
+    for s in sizes.iter_mut() {
+        *s += 1;
+    }
+}
+
+fn add_size_primitive(arr: &PrimitiveArray, sizes: &mut [u32]) {
+    let width = byte_width_u32(arr.ptype().byte_width());
+    add_size_const(sizes, encoded_size_for_fixed(width));
+}
+
+fn add_size_decimal(arr: &DecimalArray, sizes: &mut [u32]) {
+    let width = byte_width_u32(arr.values_type().byte_width());
+    add_size_const(sizes, encoded_size_for_fixed(width));
+}
+
+fn add_size_varbinview(
+    arr: &VarBinViewArray,
+    sizes: &mut [u32],
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<()> {
+    let views = arr.views();
+    match resolve_validity(arr.as_ref().validity()?, arr.len(), ctx)? {
+        ValidityKind::AllValid => {
+            for (i, view) in views.iter().enumerate() {
+                let contribution = if view.is_empty() {
+                    VARLEN_EMPTY_SIZE
+                } else {
+                    encoded_size_for_non_empty_varlen(view.len() as usize)
+                };
+                sizes[i] = sizes[i]
+                    .checked_add(contribution)
+                    .vortex_expect("per-row size overflow");
+            }
+        }
+        ValidityKind::Mask(mask) => {
+            for (i, view) in views.iter().enumerate() {
+                let contribution = if !mask.value(i) {
+                    VARLEN_NULL_SIZE
+                } else if view.is_empty() {
+                    VARLEN_EMPTY_SIZE
+                } else {
+                    encoded_size_for_non_empty_varlen(view.len() as usize)
+                };
+                sizes[i] = sizes[i]
+                    .checked_add(contribution)
+                    .vortex_expect("per-row size overflow");
+            }
+        }
+    }
+    Ok(())
+}
+
+fn add_size_struct(
+    arr: &StructArray,
+    field: RowSortField,
+    sizes: &mut [u32],
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<()> {
+    let n = arr.len();
+    let mask = arr.as_ref().validity()?.execute_mask(n, ctx)?;
+    // Outer sentinel: 1 byte per row.
+    for s in sizes.iter_mut() {
+        *s = s.checked_add(1).vortex_expect("per-row size overflow");
+    }
+    // Each child contributes its per-row size when the parent is non-null, and a canonical
+    // null contribution when the parent is null. For fixed-width children both are equal,
+    // so we can simply add the fixed width to every row. For variable-width children the
+    // null contribution collapses to 1 byte, ensuring null parent rows have a constant body.
+    for child in arr.iter_unmasked_fields() {
+        match row_width_for_dtype(child.dtype())? {
+            RowWidth::Fixed(w) => add_size_const(sizes, w),
+            RowWidth::Variable => {
+                let canonical = child.clone().execute::<Canonical>(ctx)?;
+                let mut child_sizes = vec![0u32; n];
+                field_size(&canonical, field, &mut child_sizes, ctx)?;
+                for i in 0..n {
+                    let contribution = if mask.value(i) { child_sizes[i] } else { 1u32 };
+                    sizes[i] = sizes[i]
+                        .checked_add(contribution)
+                        .vortex_expect("per-row size overflow");
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn add_size_fsl(
+    arr: &FixedSizeListArray,
+    field: RowSortField,
+    sizes: &mut [u32],
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<()> {
+    let n = arr.len();
+    debug_assert_eq!(n, sizes.len());
+    let list_size = arr.list_size() as usize;
+    let mask = arr.as_ref().validity()?.execute_mask(n, ctx)?;
+    let elem_dtype = arr.elements().dtype();
+    // Outer sentinel: 1 byte per row.
+    for s in sizes.iter_mut() {
+        *s = s.checked_add(1).vortex_expect("per-row size overflow");
+    }
+    match row_width_for_dtype(elem_dtype)? {
+        RowWidth::Fixed(w) => {
+            // Each row has `list_size` fixed-width elements regardless of null parent mask.
+            let body = w
+                .checked_mul(u32::try_from(list_size).vortex_expect("list_size fits u32"))
+                .vortex_expect("FSL body width overflow");
+            add_size_const(sizes, body);
+        }
+        RowWidth::Variable => {
+            let elements = arr.elements().clone().execute::<Canonical>(ctx)?;
+            debug_assert_eq!(elements.len(), n * list_size);
+            let mut elem_sizes = vec![0u32; n * list_size];
+            field_size(&elements, field, &mut elem_sizes, ctx)?;
+            for i in 0..n {
+                let body: u32 = if mask.value(i) {
+                    let base = i * list_size;
+                    let mut sum: u32 = 0;
+                    for j in 0..list_size {
+                        sum = sum
+                            .checked_add(elem_sizes[base + j])
+                            .vortex_expect("FSL row body overflow");
+                    }
+                    sum
+                } else {
+                    // Canonical null body for FSL with variable element: one null sentinel
+                    // per element. (Each element contributes `child_null_width = 1`.)
+                    u32::try_from(list_size).vortex_expect("list_size fits u32")
+                };
+                sizes[i] = sizes[i]
+                    .checked_add(body)
+                    .vortex_expect("FSL per-row size overflow");
+            }
+        }
+    }
+    Ok(())
+}
+
+fn encode_null(
+    arr: &NullArray,
+    field: RowSortField,
+    row_offsets: &[u32],
+    col_offset: &mut [u32],
+    out: &mut [u8],
+) {
+    let sentinel = field.null_sentinel();
+    for i in 0..arr.len() {
+        let pos = (row_offsets[i] + col_offset[i]) as usize;
+        out[pos] = sentinel;
+        col_offset[i] += 1;
+    }
+}
+
+fn encode_bool(
+    arr: &BoolArray,
+    field: RowSortField,
+    row_offsets: &[u32],
+    col_offset: &mut [u32],
+    out: &mut [u8],
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<()> {
+    let bits = arr.clone().into_bit_buffer();
+    let non_null = field.non_null_sentinel();
+    let xor = if field.descending { 0xFF } else { 0x00 };
+    match resolve_validity(arr.as_ref().validity()?, arr.len(), ctx)? {
+        ValidityKind::AllValid => {
+            for i in 0..bits.len() {
+                let pos = (row_offsets[i] + col_offset[i]) as usize;
+                out[pos] = non_null;
+                // false=0x01, true=0x02 so false < true; XOR for descending
+                let raw = if bits.value(i) { 0x02u8 } else { 0x01u8 };
+                out[pos + 1] = raw ^ xor;
+                col_offset[i] += BOOL_ENCODED_SIZE;
+            }
+        }
+        ValidityKind::Mask(mask) => {
+            let null = field.null_sentinel();
+            for i in 0..bits.len() {
+                let pos = (row_offsets[i] + col_offset[i]) as usize;
+                if mask.value(i) {
+                    out[pos] = non_null;
+                    let raw = if bits.value(i) { 0x02u8 } else { 0x01u8 };
+                    out[pos + 1] = raw ^ xor;
+                } else {
+                    out[pos] = null;
+                    out[pos + 1] = 0;
+                }
+                col_offset[i] += BOOL_ENCODED_SIZE;
+            }
+        }
+    }
+    Ok(())
+}
+
+fn encode_primitive(
+    arr: &PrimitiveArray,
+    field: RowSortField,
+    row_offsets: &[u32],
+    col_offset: &mut [u32],
+    out: &mut [u8],
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<()> {
+    match_each_native_ptype!(arr.ptype(), |T| {
+        encode_primitive_typed::<T>(arr, field, row_offsets, col_offset, out, ctx)?;
+    });
+    Ok(())
+}
+
+fn encode_primitive_typed<T: NativePType + RowEncode>(
+    arr: &PrimitiveArray,
+    field: RowSortField,
+    row_offsets: &[u32],
+    col_offset: &mut [u32],
+    out: &mut [u8],
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<()> {
+    let slice: &[T] = arr.as_slice();
+    let non_null = field.non_null_sentinel();
+    let value_bytes = size_of::<T>();
+    let stride = encoded_size_for_fixed(byte_width_u32(value_bytes));
+    match resolve_validity(arr.as_ref().validity()?, arr.len(), ctx)? {
+        ValidityKind::AllValid => {
+            for (i, &v) in slice.iter().enumerate() {
+                let pos = (row_offsets[i] + col_offset[i]) as usize;
+                out[pos] = non_null;
+                v.encode_to(&mut out[pos + 1..pos + 1 + value_bytes], field.descending);
+                col_offset[i] += stride;
+            }
+        }
+        ValidityKind::Mask(mask) => {
+            let null = field.null_sentinel();
+            for (i, &v) in slice.iter().enumerate() {
+                let pos = (row_offsets[i] + col_offset[i]) as usize;
+                if mask.value(i) {
+                    out[pos] = non_null;
+                    v.encode_to(&mut out[pos + 1..pos + 1 + value_bytes], field.descending);
+                } else {
+                    out[pos] = null;
+                    // Zero-fill the value bytes.
+                    for b in &mut out[pos + 1..pos + 1 + value_bytes] {
+                        *b = 0;
+                    }
+                }
+                col_offset[i] += stride;
+            }
+        }
+    }
+    Ok(())
+}
+
+fn encode_decimal(
+    arr: &DecimalArray,
+    field: RowSortField,
+    row_offsets: &[u32],
+    col_offset: &mut [u32],
+    out: &mut [u8],
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<()> {
+    let mask = arr.as_ref().validity()?.execute_mask(arr.len(), ctx)?;
+    match arr.values_type() {
+        DecimalType::I8 => {
+            encode_decimal_typed::<i8>(arr, &mask, field, row_offsets, col_offset, out)
+        }
+        DecimalType::I16 => {
+            encode_decimal_typed::<i16>(arr, &mask, field, row_offsets, col_offset, out)
+        }
+        DecimalType::I32 => {
+            encode_decimal_typed::<i32>(arr, &mask, field, row_offsets, col_offset, out)
+        }
+        DecimalType::I64 => {
+            encode_decimal_typed::<i64>(arr, &mask, field, row_offsets, col_offset, out)
+        }
+        DecimalType::I128 => {
+            encode_decimal_typed::<i128>(arr, &mask, field, row_offsets, col_offset, out)
+        }
+        DecimalType::I256 => {
+            vortex_bail!("row encoding for Decimal256 is not yet implemented")
+        }
+    }
+    Ok(())
+}
+
+fn encode_decimal_typed<T>(
+    arr: &DecimalArray,
+    mask: &vortex_mask::Mask,
+    field: RowSortField,
+    row_offsets: &[u32],
+    col_offset: &mut [u32],
+    out: &mut [u8],
+) where
+    T: vortex_array::dtype::NativeDecimalType + RowEncode,
+{
+    let non_null = field.non_null_sentinel();
+    let null = field.null_sentinel();
+    let value_bytes = size_of::<T>();
+    let total = encoded_size_for_fixed(byte_width_u32(value_bytes));
+    let slice = arr.buffer::<T>();
+    for i in 0..slice.len() {
+        let pos = (row_offsets[i] + col_offset[i]) as usize;
+        if mask.value(i) {
+            out[pos] = non_null;
+            slice[i].encode_to(&mut out[pos + 1..pos + 1 + value_bytes], field.descending);
+        } else {
+            out[pos] = null;
+            for b in &mut out[pos + 1..pos + 1 + value_bytes] {
+                *b = 0;
+            }
+        }
+        col_offset[i] += total;
+    }
+}
+
+fn encode_varbinview(
+    arr: &VarBinViewArray,
+    field: RowSortField,
+    row_offsets: &[u32],
+    col_offset: &mut [u32],
+    out: &mut [u8],
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<()> {
+    let null_byte = varlen_null_sentinel(field);
+    let empty_byte = varlen_empty_sentinel(field);
+    let non_empty_byte = varlen_non_empty_sentinel(field);
+    let descending = field.descending;
+
+    let views = arr.views();
+    // Cache the data-buffer slices once. Inlined views (len <= 12) carry their bytes inline,
+    // so they never touch `buffers`; referenced views index into the pre-validated buffer at
+    // `offset..offset + len`. Walking views directly avoids the per-row bounds and branch work
+    // of `with_iterator`.
+    let buffers: smallvec::SmallVec<[&[u8]; 4]> = (0..arr.data_buffers().len())
+        .map(|i| arr.buffer(i).as_slice())
+        .collect();
+
+    match resolve_validity(arr.as_ref().validity()?, arr.len(), ctx)? {
+        ValidityKind::AllValid => {
+            for (i, view) in views.iter().enumerate() {
+                let pos = (row_offsets[i] + col_offset[i]) as usize;
+                let len = view.len() as usize;
+                if len == 0 {
+                    out[pos] = empty_byte;
+                    col_offset[i] += VARLEN_EMPTY_SIZE;
+                    continue;
+                }
+                let bytes: &[u8] = if view.is_inlined() {
+                    view.as_inlined().value()
+                } else {
+                    let r = view.as_view();
+                    let off = r.offset as usize;
+                    &buffers[r.buffer_index as usize][off..off + len]
+                };
+                out[pos] = non_empty_byte;
+                let written = encode_non_empty_varlen_body(bytes, &mut out[pos + 1..], descending);
+                col_offset[i] += 1 + written;
+            }
+        }
+        ValidityKind::Mask(mask) => {
+            for (i, view) in views.iter().enumerate() {
+                let pos = (row_offsets[i] + col_offset[i]) as usize;
+                if !mask.value(i) {
+                    out[pos] = null_byte;
+                    col_offset[i] += VARLEN_NULL_SIZE;
+                    continue;
+                }
+                let len = view.len() as usize;
+                if len == 0 {
+                    out[pos] = empty_byte;
+                    col_offset[i] += VARLEN_EMPTY_SIZE;
+                    continue;
+                }
+                let bytes: &[u8] = if view.is_inlined() {
+                    view.as_inlined().value()
+                } else {
+                    let r = view.as_view();
+                    let off = r.offset as usize;
+                    &buffers[r.buffer_index as usize][off..off + len]
+                };
+                out[pos] = non_empty_byte;
+                let written = encode_non_empty_varlen_body(bytes, &mut out[pos + 1..], descending);
+                col_offset[i] += 1 + written;
+            }
+        }
+    }
+    Ok(())
+}
+
+fn encode_struct(
+    arr: &StructArray,
+    field: RowSortField,
+    row_offsets: &[u32],
+    col_offset: &mut [u32],
+    out: &mut [u8],
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<()> {
+    let n = arr.len();
+    let mask = arr.as_ref().validity()?.execute_mask(n, ctx)?;
+    let non_null = field.non_null_sentinel();
+    let null = field.null_sentinel();
+
+    // Write the outer sentinel for each row.
+    for i in 0..n {
+        let pos = (row_offsets[i] + col_offset[i]) as usize;
+        out[pos] = if mask.value(i) { non_null } else { null };
+        col_offset[i] += 1;
+    }
+
+    // Encode each child. For non-null parent rows the child contributes its actual encoding;
+    // for null parent rows the child contributes its canonical null encoding so that two null
+    // parent rows produce byte-equal output regardless of underlying child values.
+    for child in arr.iter_unmasked_fields() {
+        match row_width_for_dtype(child.dtype())? {
+            RowWidth::Fixed(w) => {
+                let canonical = child.clone().execute::<Canonical>(ctx)?;
+                field_encode(&canonical, field, row_offsets, col_offset, out, ctx)?;
+                // Replace null parent rows with the canonical null encoding (the same as a
+                // child-level null: null sentinel followed by zero-padded value bytes).
+                let null_byte = child_canonical_null_byte(child.dtype(), field);
+                for i in 0..n {
+                    if !mask.value(i) {
+                        let end = (row_offsets[i] + col_offset[i]) as usize;
+                        let start = end - w as usize;
+                        out[start] = null_byte;
+                        for b in &mut out[start + 1..end] {
+                            *b = 0;
+                        }
+                    }
+                }
+            }
+            RowWidth::Variable => {
+                encode_variable_child(child, field, &mask, row_offsets, col_offset, out, ctx)?;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn encode_fsl(
+    arr: &FixedSizeListArray,
+    field: RowSortField,
+    row_offsets: &[u32],
+    col_offset: &mut [u32],
+    out: &mut [u8],
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<()> {
+    let nrows = arr.len();
+    let list_size = arr.list_size() as usize;
+    let mask = arr.as_ref().validity()?.execute_mask(nrows, ctx)?;
+    let non_null = field.non_null_sentinel();
+    let null = field.null_sentinel();
+    let elem_dtype = arr.elements().dtype().clone();
+
+    // Outer sentinel.
+    for i in 0..nrows {
+        let pos = (row_offsets[i] + col_offset[i]) as usize;
+        out[pos] = if mask.value(i) { non_null } else { null };
+        col_offset[i] += 1;
+    }
+
+    match row_width_for_dtype(&elem_dtype)? {
+        RowWidth::Fixed(w) => {
+            // Fixed-width elements: encode the elements array directly (its length is
+            // nrows * list_size) using a derived (offsets, cursors) pair. Then overwrite
+            // the body of null parent rows with the canonical null encoding per element.
+            let elements = arr.elements().clone().execute::<Canonical>(ctx)?;
+            debug_assert_eq!(elements.len(), nrows * list_size);
+            let list_size_u32 = arr.list_size();
+            let row_body_bytes = w
+                .checked_mul(list_size_u32)
+                .vortex_expect("FSL body width overflow");
+            let mut elem_offsets = vec![0u32; nrows * list_size];
+            for i in 0..nrows {
+                let base = row_offsets[i] + col_offset[i];
+                for j in 0u32..list_size_u32 {
+                    elem_offsets[i * list_size + j as usize] = base + j * w;
+                }
+            }
+            let mut elem_cursors = vec![0u32; nrows * list_size];
+            field_encode(&elements, field, &elem_offsets, &mut elem_cursors, out, ctx)?;
+            for i in 0..nrows {
+                col_offset[i] = col_offset[i]
+                    .checked_add(row_body_bytes)
+                    .vortex_expect("FSL row body overflow");
+            }
+            // Canonical null body for null parent rows: one null encoding per element.
+            let null_byte = child_canonical_null_byte(&elem_dtype, field);
+            let elem_width = w as usize;
+            for i in 0..nrows {
+                if !mask.value(i) {
+                    let end = (row_offsets[i] + col_offset[i]) as usize;
+                    let start = end - row_body_bytes as usize;
+                    let mut pos = start;
+                    for _ in 0..list_size {
+                        out[pos] = null_byte;
+                        for b in &mut out[pos + 1..pos + elem_width] {
+                            *b = 0;
+                        }
+                        pos += elem_width;
+                    }
+                }
+            }
+        }
+        RowWidth::Variable => {
+            // Variable-width elements: for null parent rows the canonical body is exactly
+            // `list_size` null sentinel bytes (one per element). For non-null parent rows,
+            // encode each element via a scratch buffer and copy into out.
+            let elements = arr.elements().clone().execute::<Canonical>(ctx)?;
+            debug_assert_eq!(elements.len(), nrows * list_size);
+            let mut elem_sizes = vec![0u32; nrows * list_size];
+            field_size(&elements, field, &mut elem_sizes, ctx)?;
+            let total: u64 = elem_sizes.iter().map(|&s| u64::from(s)).sum();
+            let total_usize =
+                usize::try_from(total).vortex_expect("FSL scratch buffer size fits usize");
+            let mut scratch = vec![0u8; total_usize];
+            let mut scratch_offsets = Vec::with_capacity(nrows * list_size);
+            let mut acc: u32 = 0;
+            for &s in &elem_sizes {
+                scratch_offsets.push(acc);
+                acc = acc
+                    .checked_add(s)
+                    .vortex_expect("FSL scratch offset overflow");
+            }
+            let mut scratch_cursors = vec![0u32; nrows * list_size];
+            field_encode(
+                &elements,
+                field,
+                &scratch_offsets,
+                &mut scratch_cursors,
+                &mut scratch,
+                ctx,
+            )?;
+            let null_byte = child_canonical_null_byte(&elem_dtype, field);
+            for i in 0..nrows {
+                let dst = (row_offsets[i] + col_offset[i]) as usize;
+                if mask.value(i) {
+                    let mut body_bytes: u32 = 0;
+                    for j in 0..list_size {
+                        let k = i * list_size + j;
+                        let src = scratch_offsets[k] as usize;
+                        let sz = elem_sizes[k] as usize;
+                        out[dst + body_bytes as usize..dst + body_bytes as usize + sz]
+                            .copy_from_slice(&scratch[src..src + sz]);
+                        body_bytes = body_bytes
+                            .checked_add(elem_sizes[k])
+                            .vortex_expect("FSL body bytes overflow");
+                    }
+                    col_offset[i] = col_offset[i]
+                        .checked_add(body_bytes)
+                        .vortex_expect("FSL row offset overflow");
+                } else {
+                    for offset in 0..list_size {
+                        out[dst + offset] = null_byte;
+                    }
+                    col_offset[i] = col_offset[i]
+                        .checked_add(u32::try_from(list_size).vortex_expect("list_size fits u32"))
+                        .vortex_expect("FSL row offset overflow");
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Encode one variable-width child of a struct: for non-null parent rows, copy the child's
+/// natural encoding from a scratch buffer; for null parent rows, write a single
+/// `child_canonical_null_byte`.
+fn encode_variable_child(
+    child: &vortex_array::ArrayRef,
+    field: RowSortField,
+    parent_mask: &vortex_mask::Mask,
+    row_offsets: &[u32],
+    col_offset: &mut [u32],
+    out: &mut [u8],
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<()> {
+    let n = child.len();
+    let canonical = child.clone().execute::<Canonical>(ctx)?;
+
+    // Size and encode the child into a sequential scratch buffer.
+    let mut child_sizes = vec![0u32; n];
+    field_size(&canonical, field, &mut child_sizes, ctx)?;
+    let total: u64 = child_sizes.iter().map(|&s| u64::from(s)).sum();
+    let total_usize = usize::try_from(total).vortex_expect("child scratch buffer size fits usize");
+    let mut scratch = vec![0u8; total_usize];
+    let mut scratch_offsets = Vec::with_capacity(n);
+    let mut acc: u32 = 0;
+    for &s in &child_sizes {
+        scratch_offsets.push(acc);
+        acc = acc
+            .checked_add(s)
+            .vortex_expect("child scratch offset overflow");
+    }
+    let mut scratch_cursors = vec![0u32; n];
+    field_encode(
+        &canonical,
+        field,
+        &scratch_offsets,
+        &mut scratch_cursors,
+        &mut scratch,
+        ctx,
+    )?;
+
+    let null_byte = child_canonical_null_byte(child.dtype(), field);
+    for i in 0..n {
+        let dst = (row_offsets[i] + col_offset[i]) as usize;
+        if parent_mask.value(i) {
+            let src = scratch_offsets[i] as usize;
+            let sz = child_sizes[i] as usize;
+            out[dst..dst + sz].copy_from_slice(&scratch[src..src + sz]);
+            col_offset[i] = col_offset[i]
+                .checked_add(child_sizes[i])
+                .vortex_expect("col_offset overflow");
+        } else {
+            out[dst] = null_byte;
+            col_offset[i] = col_offset[i]
+                .checked_add(1)
+                .vortex_expect("col_offset overflow");
+        }
+    }
+    Ok(())
+}
+
+/// Arithmetic-write primitive encoder: writes each row's `sentinel + value` slot at a
+/// constant within-row offset, iterating the output in `row_stride`-sized chunks so the
+/// compiler can drop the per-row offset/cursor indirection.
+fn encode_primitive_arith(
+    arr: &PrimitiveArray,
+    field: RowSortField,
+    col_prefix: u32,
+    row_stride: u32,
+    out: &mut [u8],
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<()> {
+    match_each_native_ptype!(arr.ptype(), |T| {
+        encode_primitive_arith_typed::<T>(arr, field, col_prefix, row_stride, out, ctx)?;
+    });
+    Ok(())
+}
+
+fn encode_primitive_arith_typed<T: NativePType + RowEncode>(
+    arr: &PrimitiveArray,
+    field: RowSortField,
+    col_prefix: u32,
+    row_stride: u32,
+    out: &mut [u8],
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<()> {
+    let slice: &[T] = arr.as_slice();
+    let non_null = field.non_null_sentinel();
+    let value_bytes = size_of::<T>();
+    let slot_size = 1 + value_bytes;
+    let stride = row_stride as usize;
+    let prefix = col_prefix as usize;
+    let descending = field.descending;
+
+    match resolve_validity(arr.as_ref().validity()?, arr.len(), ctx)? {
+        ValidityKind::AllValid => {
+            // Hot path: each row's slot is a fixed window inside its `stride`-sized chunk,
+            // so the inner write vectorizes the same way as `arrow-row`'s not-null path.
+            for (chunk, &v) in out.chunks_exact_mut(stride).zip(slice.iter()) {
+                let slot = &mut chunk[prefix..prefix + slot_size];
+                slot[0] = non_null;
+                v.encode_to(&mut slot[1..], descending);
+            }
+        }
+        ValidityKind::Mask(mask) => {
+            let null = field.null_sentinel();
+            for (i, (chunk, &v)) in out.chunks_exact_mut(stride).zip(slice.iter()).enumerate() {
+                let slot = &mut chunk[prefix..prefix + slot_size];
+                if mask.value(i) {
+                    slot[0] = non_null;
+                    v.encode_to(&mut slot[1..], descending);
+                } else {
+                    slot[0] = null;
+                    for b in &mut slot[1..] {
+                        *b = 0;
+                    }
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Encode a non-empty variable-length byte slice into `out` in 32-byte blocks with
+/// continuation/length markers. Returns the number of bytes written. Empty values are
+/// encoded by the caller as a single sentinel byte and never reach this function.
+///
+/// For the ascending path the hot loop is a `copy_nonoverlapping` of 32 bytes per block
+/// plus one stamped continuation byte. For the descending path it reads a u64 at a time and
+/// XORs with `0xFF`, giving LLVM a vectorizable inner loop.
+fn encode_non_empty_varlen_body(bytes: &[u8], out: &mut [u8], descending: bool) -> u32 {
+    debug_assert!(!bytes.is_empty());
+    let len = bytes.len();
+    let full_blocks = len / VARLEN_BLOCK_SIZE;
+    let partial = len % VARLEN_BLOCK_SIZE;
+    let (full_to_write, partial_block_len) = if partial == 0 {
+        // Length is an exact multiple of 32: emit (full_blocks - 1) full blocks with the
+        // 0xFF continuation marker, then a final block whose continuation byte is 32.
+        (full_blocks - 1, VARLEN_BLOCK_SIZE)
+    } else {
+        (full_blocks, partial)
+    };
+    let total = (full_to_write + 1) * VARLEN_BLOCK_TOTAL;
+    debug_assert!(out.len() >= total);
+    // The final block's continuation byte encodes its content length (1..=32).
+    let len_byte =
+        u8::try_from(partial_block_len).vortex_expect("varlen final block length (1..=32) fits u8");
+
+    // SAFETY: `out` has at least `total` bytes — the caller sizes every varlen slot via
+    // `encoded_size_for_non_empty_varlen` (which equals `1 + total`, the extra byte being the
+    // leading sentinel that the caller wrote and that is not part of `out`). `bytes` is valid
+    // for `len` reads, and every pointer advance below stays within `[0, total)` for `dst`
+    // and `[0, len)` for `src`.
+    unsafe {
+        let mut src = bytes.as_ptr();
+        let mut dst = out.as_mut_ptr();
+
+        if !descending {
+            // Ascending fast path: each full block is a 32-byte memcpy + a single 0xFF stamp.
+            for _ in 0..full_to_write {
+                std::ptr::copy_nonoverlapping(src, dst, VARLEN_BLOCK_SIZE);
+                *dst.add(VARLEN_BLOCK_SIZE) = 0xFF;
+                src = src.add(VARLEN_BLOCK_SIZE);
+                dst = dst.add(VARLEN_BLOCK_TOTAL);
+            }
+            // Final block: copy the partial data, zero-pad the tail, write the length byte.
+            std::ptr::copy_nonoverlapping(src, dst, partial_block_len);
+            std::ptr::write_bytes(
+                dst.add(partial_block_len),
+                0,
+                VARLEN_BLOCK_SIZE - partial_block_len,
+            );
+            *dst.add(VARLEN_BLOCK_SIZE) = len_byte;
+        } else {
+            // Descending: invert every value byte. A u64-stride XOR gives LLVM a vectorizable
+            // inner loop; the tail handles the partial block byte-wise.
+            for _ in 0..full_to_write {
+                xor_copy_block(src, dst);
+                *dst.add(VARLEN_BLOCK_SIZE) = 0x00; // descending counterpart of 0xFF
+                src = src.add(VARLEN_BLOCK_SIZE);
+                dst = dst.add(VARLEN_BLOCK_TOTAL);
+            }
+            for i in 0..partial_block_len {
+                *dst.add(i) = *src.add(i) ^ 0xFF;
+            }
+            std::ptr::write_bytes(
+                dst.add(partial_block_len),
+                0xFF, // 0x00 XOR 0xFF
+                VARLEN_BLOCK_SIZE - partial_block_len,
+            );
+            *dst.add(VARLEN_BLOCK_SIZE) = len_byte ^ 0xFF;
+        }
+    }
+    u32::try_from(total).vortex_expect("encoded varlen byte length fits u32")
+}
+
+/// Copy 32 bytes from `src` to `dst`, XORing each with `0xFF`. LLVM auto-vectorizes the
+/// four u64-wide iterations into SIMD on x86.
+///
+/// # Safety
+/// `src` must be valid for 32 reads, `dst` valid for 32 writes, and the regions must not
+/// overlap.
+#[inline(always)]
+unsafe fn xor_copy_block(src: *const u8, dst: *mut u8) {
+    // Four u64 lanes of 8 bytes each = 32 bytes total.
+    for i in 0..4 {
+        let off = i * 8;
+        // SAFETY: the caller guarantees src/dst are valid for the full 32-byte block.
+        let v = unsafe { std::ptr::read_unaligned(src.add(off) as *const u64) };
+        unsafe { std::ptr::write_unaligned(dst.add(off) as *mut u64, v ^ u64::MAX) };
+    }
+}
+
+/// Internal trait for encoding a fixed-width native value into byte slots.
+///
+/// Implementations must produce a sequence of `size_of::<Self>()` bytes that is
+/// lexicographically byte-comparable according to the natural ordering of the type.
+pub(crate) trait RowEncode: Copy {
+    /// Encode this value into `out`, inverting the bytes for descending order.
+    fn encode_to(self, out: &mut [u8], descending: bool);
+}
+
+macro_rules! impl_row_encode_unsigned {
+    ($t:ty) => {
+        impl RowEncode for $t {
+            #[inline]
+            fn encode_to(self, out: &mut [u8], descending: bool) {
+                let bytes = self.to_be_bytes();
+                if descending {
+                    for (i, b) in bytes.iter().enumerate() {
+                        out[i] = b ^ 0xFF;
+                    }
+                } else {
+                    out.copy_from_slice(&bytes);
+                }
+            }
+        }
+    };
+}
+
+macro_rules! impl_row_encode_signed {
+    ($t:ty) => {
+        impl RowEncode for $t {
+            #[inline]
+            fn encode_to(self, out: &mut [u8], descending: bool) {
+                let mut bytes = self.to_be_bytes();
+                // Flip sign bit so negatives < non-negatives lexicographically.
+                bytes[0] ^= 0x80;
+                if descending {
+                    for (i, b) in bytes.iter().enumerate() {
+                        out[i] = b ^ 0xFF;
+                    }
+                } else {
+                    out.copy_from_slice(&bytes);
+                }
+            }
+        }
+    };
+}
+
+impl_row_encode_unsigned!(u8);
+impl_row_encode_unsigned!(u16);
+impl_row_encode_unsigned!(u32);
+impl_row_encode_unsigned!(u64);
+impl_row_encode_signed!(i8);
+impl_row_encode_signed!(i16);
+impl_row_encode_signed!(i32);
+impl_row_encode_signed!(i64);
+impl_row_encode_signed!(i128);
+
+impl RowEncode for f32 {
+    fn encode_to(self, out: &mut [u8], descending: bool) {
+        let bits = self.to_bits();
+        let mask: u32 = if (bits >> 31) == 0 {
+            0x8000_0000
+        } else {
+            0xFFFF_FFFF
+        };
+        let mut bytes = (bits ^ mask).to_be_bytes();
+        if descending {
+            for b in bytes.iter_mut() {
+                *b ^= 0xFF;
+            }
+        }
+        out.copy_from_slice(&bytes);
+    }
+}
+
+impl RowEncode for f64 {
+    fn encode_to(self, out: &mut [u8], descending: bool) {
+        let bits = self.to_bits();
+        let mask: u64 = if (bits >> 63) == 0 {
+            0x8000_0000_0000_0000
+        } else {
+            0xFFFF_FFFF_FFFF_FFFF
+        };
+        let mut bytes = (bits ^ mask).to_be_bytes();
+        if descending {
+            for b in bytes.iter_mut() {
+                *b ^= 0xFF;
+            }
+        }
+        out.copy_from_slice(&bytes);
+    }
+}
+
+impl RowEncode for f16 {
+    fn encode_to(self, out: &mut [u8], descending: bool) {
+        let bits = self.to_bits();
+        let mask: u16 = if (bits >> 15) == 0 { 0x8000 } else { 0xFFFF };
+        let mut bytes = (bits ^ mask).to_be_bytes();
+        if descending {
+            for b in bytes.iter_mut() {
+                *b ^= 0xFF;
+            }
+        }
+        out.copy_from_slice(&bytes);
+    }
+}
diff --git a/vortex-row/src/encode.rs b/vortex-row/src/encode.rs
new file mode 100644
index 00000000000..04feec89415
--- /dev/null
+++ b/vortex-row/src/encode.rs
@@ -0,0 +1,275 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! `RowEncode` variadic scalar function: encode N input columns into a single `ListView<u8>`.
+//!
+//! The output's `(elements, offsets, sizes)` triple is built up in a single left-to-right
+//! pass over the input columns. The `sizes` array doubles as the per-row write cursor, so
+//! when the last column finishes encoding, the accumulator is the final array - no separate
+//! conversion step is needed.
+
+use std::sync::Arc;
+
+use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
+use vortex_array::arrays::ListViewArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::Nullability;
+use vortex_array::dtype::PType;
+use vortex_array::scalar_fn::Arity;
+use vortex_array::scalar_fn::ChildName;
+use vortex_array::scalar_fn::ExecutionArgs;
+use vortex_array::scalar_fn::ScalarFnId;
+use vortex_array::scalar_fn::ScalarFnVTable;
+use vortex_array::validity::Validity;
+use vortex_buffer::BufferMut;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_session::VortexSession;
+
+use crate::codec;
+use crate::options::RowEncodingOptions;
+use crate::options::deserialize_row_encoding_options;
+use crate::options::serialize_row_encoding_options;
+use crate::size::ColKind;
+use crate::size::compute_sizes;
+
+/// Variadic scalar function that encodes N input columns into a single `List<u8>`
+/// [`ListViewArray`] where row `i` contains the row-encoded bytes for column values
+/// `cols[0][i], cols[1][i], ...` concatenated left-to-right.
+///
+/// This scalar function is public for session registration and row-encoding work.
+/// Most callers should use [`RowEncoder`](crate::RowEncoder) rather than invoking the scalar
+/// function directly.
+#[derive(Clone, Debug)]
+pub struct RowEncode;
+
+impl ScalarFnVTable for RowEncode {
+    type Options = RowEncodingOptions;
+
+    fn id(&self) -> ScalarFnId {
+        ScalarFnId::from("vortex.row_encode")
+    }
+
+    fn serialize(&self, options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(serialize_row_encoding_options(options)))
+    }
+
+    fn deserialize(
+        &self,
+        metadata: &[u8],
+        _session: &VortexSession,
+    ) -> VortexResult<Self::Options> {
+        deserialize_row_encoding_options(metadata)
+    }
+
+    fn arity(&self, _options: &Self::Options) -> Arity {
+        Arity::Variadic { min: 1, max: None }
+    }
+
+    fn child_name(&self, _options: &Self::Options, child_idx: usize) -> ChildName {
+        ChildName::from(Arc::from(format!("col_{}", child_idx)))
+    }
+
+    fn return_dtype(&self, _options: &Self::Options, _args: &[DType]) -> VortexResult<DType> {
+        Ok(DType::List(
+            Arc::new(DType::Primitive(PType::U8, Nullability::NonNullable)),
+            Nullability::NonNullable,
+        ))
+    }
+
+    fn execute(
+        &self,
+        options: &Self::Options,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        execute_row_encode(options, args, ctx)
+    }
+
+    fn is_null_sensitive(&self, _options: &Self::Options) -> bool {
+        true
+    }
+
+    fn is_fallible(&self, _options: &Self::Options) -> bool {
+        false
+    }
+}
+
+fn execute_row_encode(
+    options: &RowEncodingOptions,
+    args: &dyn ExecutionArgs,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ArrayRef> {
+    let nrows = args.row_count();
+    if u32::try_from(nrows).is_err() {
+        vortex_bail!("row-encoded input has {} rows, exceeds u32::MAX", nrows);
+    }
+
+    // ===== Phase 1: classify + size pass =====
+    let crate::size::SizePassResult {
+        fixed_per_row,
+        var_lengths,
+        col_kinds,
+        first_varlen_idx,
+        columns,
+    } = compute_sizes(options, args, ctx)?;
+
+    // ===== Phase 2: totals + buffer =====
+    let var_total: u64 = var_lengths
+        .as_ref()
+        .map_or(0, |v| v.iter().map(|&x| u64::from(x)).sum());
+    let total: u64 = (nrows as u64)
+        .checked_mul(u64::from(fixed_per_row))
+        .and_then(|t| t.checked_add(var_total))
+        .ok_or_else(|| {
+            vortex_error::vortex_err!("row-encoded total bytes overflow u64 (nrows * fixed + var)")
+        })?;
+    if total > u32::MAX as u64 {
+        vortex_bail!("row-encoded output size {} bytes exceeds u32::MAX", total);
+    }
+    let total_len =
+        usize::try_from(total).vortex_expect("validated row-encoded output size must fit usize");
+
+    let mut out_buf: BufferMut<u8> = BufferMut::with_capacity(total_len);
+    // Every encoder writes every byte in its row range: fixed-width values write
+    // sentinel + value (null rows write sentinel + explicit zero-fill); varlen blocks
+    // zero-pad their final partial block; struct/FSL fixed children are written for all
+    // rows then null parent rows are overwritten with the canonical null body. So the
+    // size-pass + encoder contract guarantees `[0, total_len)` is fully written before
+    // the buffer is read out, making the pre-zero-init redundant. Skipping it saves a
+    // `total_len`-byte memset per call (significant for varlen-heavy inputs, where
+    // `total_len` reaches multiple MB).
+    //
+    // SAFETY: `total_len` bytes of capacity were just reserved, and by the contract above
+    // every byte in that range is written before `out_buf` is frozen and read.
+    unsafe { out_buf.set_len(total_len) };
+
+    // ===== Phase 3: per-row offsets =====
+    // listview_offsets[i] is the absolute byte offset where row `i` begins.
+    // For pure-fixed: i * fixed_per_row.
+    // For mixed: i * fixed_per_row + exclusive prefix sum of var_lengths.
+    //
+    // When fixed-before-varlen columns coexist with a varlen column, we additionally build
+    // `var_prefix_for_arith[i] = exclusive cumsum of var_lengths[..i]` and hand it to the
+    // arithmetic encoders so they can compute per-row write positions without a cursor.
+    let need_arith_prefix = first_varlen_idx.is_some()
+        && col_kinds.iter().any(|k| {
+            matches!(
+                k,
+                ColKind::Fixed {
+                    before_varlen: true,
+                    ..
+                }
+            )
+        });
+
+    // Build directly into a BufferMut to avoid a Vec→Buffer copy at the end.
+    let mut listview_offsets: BufferMut<u32> = BufferMut::with_capacity(nrows);
+    // SAFETY: `nrows` of capacity reserved above; every index in `[0, nrows)` is written
+    // before the buffer is read out. `nrows` was validated to fit `u32` at function entry,
+    // so the `0u32..` counters below are exact and the multiplications can't overflow.
+    unsafe { listview_offsets.set_len(nrows) };
+    let off = listview_offsets.as_mut_slice();
+    let mut var_prefix_for_arith: Option<Vec<u32>> = None;
+    match var_lengths.as_ref() {
+        None => {
+            // Pure-fixed: offsets[i] = i * fixed_per_row. Zipping against a `u32` counter
+            // elides per-element bounds checks, so LLVM auto-vectorizes this multiply.
+            for (slot, i) in off.iter_mut().zip(0u32..) {
+                *slot = i * fixed_per_row;
+            }
+        }
+        Some(v) => {
+            // Mixed: offsets[i] = i * fixed_per_row + var_prefix[i], where var_prefix is the
+            // exclusive cumsum of varlen lengths. The total was validated to fit u32 upstream
+            // so the wrapping arithmetic is exact (it never actually wraps).
+            let mut vp: Option<Vec<u32>> = need_arith_prefix.then(|| Vec::with_capacity(nrows));
+            let mut acc: u32 = 0;
+            for ((slot, &l), i) in off.iter_mut().zip(v.iter()).zip(0u32..) {
+                if let Some(p) = vp.as_mut() {
+                    p.push(acc);
+                }
+                *slot = i.wrapping_mul(fixed_per_row).wrapping_add(acc);
+                acc = acc.wrapping_add(l);
+            }
+            var_prefix_for_arith = vp;
+        }
+    }
+    let listview_offsets_slice: &[u32] = listview_offsets.as_slice();
+
+    // Per-row write cursor (also doubles as the ListView `sizes` slot when done). We build
+    // it as a BufferMut so we can hand it directly to the output PrimitiveArray.
+    //
+    // The cursor path begins at the first cursor-path column. Fixed-before-varlen columns
+    // are written by the arithmetic path and do not touch the cursor, so the cursor is
+    // pre-seeded with the within-row offset of the first varlen column (its `fixed_prefix`).
+    // When there are no varlen columns at all, every column takes the arithmetic path and
+    // the cursor loop runs zero iterations; seeding with `fixed_per_row` then leaves the
+    // cursors already correct as per-row sizes.
+    let initial_cursor: u32 = match first_varlen_idx {
+        Some(idx) => match col_kinds[idx] {
+            ColKind::Variable { fixed_prefix } => fixed_prefix,
+            ColKind::Fixed { .. } => unreachable!("first_varlen_idx points at a varlen column"),
+        },
+        None => fixed_per_row,
+    };
+    let mut row_cursors: BufferMut<u32> = BufferMut::with_capacity(nrows);
+    row_cursors.push_n(initial_cursor, nrows);
+
+    // ===== Phase 4: encode columns =====
+    // Fixed-before-varlen columns take the arithmetic-write path (constant within-row
+    // offset, no cursor mutation). Fixed-after-varlen and varlen columns take the cursor
+    // path. Each column was canonicalized once during the size pass; reuse that form.
+    for (i, canonical) in columns.iter().enumerate() {
+        match col_kinds[i] {
+            ColKind::Fixed {
+                prefix,
+                before_varlen: true,
+                ..
+            } => {
+                codec::field_encode_fixed_arithmetic(
+                    canonical,
+                    options.fields[i],
+                    prefix,
+                    fixed_per_row,
+                    var_prefix_for_arith.as_deref(),
+                    nrows,
+                    &mut out_buf,
+                    ctx,
+                )?;
+            }
+            ColKind::Fixed { .. } | ColKind::Variable { .. } => {
+                codec::field_encode(
+                    canonical,
+                    options.fields[i],
+                    listview_offsets_slice,
+                    row_cursors.as_mut_slice(),
+                    &mut out_buf,
+                    ctx,
+                )?;
+            }
+        }
+    }
+
+    // ===== Phase 5: build ListView output =====
+    let elements = PrimitiveArray::new(out_buf.freeze(), Validity::NonNullable).into_array();
+    let offsets_arr =
+        PrimitiveArray::new(listview_offsets.freeze(), Validity::NonNullable).into_array();
+    let sizes_arr = PrimitiveArray::new(row_cursors.freeze(), Validity::NonNullable).into_array();
+    // SAFETY: this encoder constructs `elements`, `offsets_arr`, and `sizes_arr` itself:
+    // - `elements` is a `PrimitiveArray<u8>` of length `total_len`.
+    // - `offsets_arr[i]` is `i * fixed_per_row + var_prefix[i]`, monotonically increasing and
+    //   in `0..=total_len`.
+    // - `offsets_arr[i] + sizes_arr[i] <= total_len` by construction, and each row's slice is
+    //   disjoint from every other row's.
+    // `try_new`'s validation re-walks every row to check exactly these invariants, which we
+    // already guarantee by construction, so we skip it.
+    Ok(unsafe {
+        ListViewArray::new_unchecked(elements, offsets_arr, sizes_arr, Validity::NonNullable)
+    }
+    .into_array())
+}
diff --git a/vortex-row/src/encoder.rs b/vortex-row/src/encoder.rs
new file mode 100644
index 00000000000..7bcd3e05627
--- /dev/null
+++ b/vortex-row/src/encoder.rs
@@ -0,0 +1,161 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! User-facing entry point: turn N columnar arrays into one row-encoded `ListView<u8>`.
+
+use vortex_array::ArrayRef;
+use vortex_array::ExecutionCtx;
+use vortex_array::arrays::ListViewArray;
+use vortex_array::dtype::DType;
+use vortex_array::scalar_fn::ScalarFnVTable;
+use vortex_array::scalar_fn::VecExecutionArgs;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+
+use crate::encode::RowEncode;
+use crate::options::RowEncodingOptions;
+use crate::options::RowSortField;
+use crate::size::RowSize;
+
+/// Encodes N columnar arrays into a single row-oriented [`ListViewArray`] of `u8` whose row
+/// byte slices compare lexicographically in the same order as a tuple comparison of the input
+/// values under the configured [`RowSortField`]s.
+///
+/// Construct with [`RowEncoder::new`] or [`RowEncoder::with_options`] to pin the per-column
+/// sort options, or use [`RowEncoder::default`] to apply ascending, nulls-first ordering to
+/// every column. The same encoder can be reused across calls.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct RowEncoder {
+    options: Option<RowEncodingOptions>,
+}
+
+impl RowEncoder {
+    /// Construct a `RowEncoder` from one [`RowSortField`] per input column.
+    pub fn new(fields: impl IntoIterator<Item = RowSortField>) -> Self {
+        Self {
+            options: Some(RowEncodingOptions::new(fields)),
+        }
+    }
+
+    /// Construct a `RowEncoder` from an explicit [`RowEncodingOptions`].
+    pub fn with_options(options: RowEncodingOptions) -> Self {
+        Self {
+            options: Some(options),
+        }
+    }
+
+    /// Borrow the configured options, or `None` when the encoder applies default
+    /// (ascending, nulls-first) ordering inferred from the column count at encode time.
+    pub fn options(&self) -> Option<&RowEncodingOptions> {
+        self.options.as_ref()
+    }
+
+    /// Encode `cols` into a single row-oriented [`ListViewArray`] of `u8`.
+    pub fn encode(&self, cols: &[ArrayRef], ctx: &mut ExecutionCtx) -> VortexResult<ListViewArray> {
+        let (options, args) = self.prepare(cols)?;
+        RowEncode
+            .execute(&options, &args, ctx)?
+            .execute::<ListViewArray>(ctx)
+    }
+
+    /// Compute only the per-row sizes (the `Struct { fixed: u32, var: u32 }` produced by
+    /// [`RowSize`]) without materializing the encoded rows.
+    pub fn row_sizes(&self, cols: &[ArrayRef], ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
+        let (options, args) = self.prepare(cols)?;
+        RowSize.execute(&options, &args, ctx)
+    }
+
+    /// Validate the input columns and resolve the options + execution args shared by
+    /// [`encode`](Self::encode) and [`row_sizes`](Self::row_sizes).
+    fn prepare(&self, cols: &[ArrayRef]) -> VortexResult<(RowEncodingOptions, VecExecutionArgs)> {
+        if cols.is_empty() {
+            vortex_bail!("RowEncoder: at least one column is required");
+        }
+        let options = match &self.options {
+            Some(options) => {
+                if options.len() != cols.len() {
+                    vortex_bail!(
+                        "RowEncoder: options describe {} columns but {} were provided",
+                        options.len(),
+                        cols.len()
+                    );
+                }
+                options.clone()
+            }
+            None => RowEncodingOptions::default_for_columns(cols.len()),
+        };
+        let nrows = cols[0].len();
+        for (i, col) in cols.iter().enumerate() {
+            reject_extension_dtype(col.dtype())?;
+            if col.len() != nrows {
+                vortex_bail!(
+                    "RowEncoder: column {} has length {} but expected {}",
+                    i,
+                    col.len(),
+                    nrows
+                );
+            }
+        }
+        Ok((options, VecExecutionArgs::new(cols.to_vec(), nrows)))
+    }
+}
+
+fn reject_extension_dtype(dtype: &DType) -> VortexResult<()> {
+    match dtype {
+        DType::Extension(ext_dtype) => {
+            vortex_bail!(
+                "row encoding does not support Extension arrays yet: {}",
+                ext_dtype.id()
+            )
+        }
+        DType::Struct(fields, _) => {
+            for field_dtype in fields.fields() {
+                reject_extension_dtype(&field_dtype)?;
+            }
+        }
+        DType::FixedSizeList(elem, ..) | DType::List(elem, _) => {
+            reject_extension_dtype(elem)?;
+        }
+        _ => {}
+    }
+    Ok(())
+}
+
+/// Convert N columnar arrays into a single row-oriented [`ListViewArray`] of `u8` whose bytes
+/// are lexicographically comparable in the same order as a tuple comparison of the input
+/// values according to `fields`. Convenience wrapper over [`RowEncoder::encode`].
+pub fn convert_columns(
+    cols: &[ArrayRef],
+    fields: &[RowSortField],
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ListViewArray> {
+    RowEncoder::new(fields.iter().copied()).encode(cols, ctx)
+}
+
+/// Like [`convert_columns`] but takes a prebuilt [`RowEncodingOptions`].
+pub fn convert_columns_with_options(
+    cols: &[ArrayRef],
+    options: &RowEncodingOptions,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ListViewArray> {
+    RowEncoder::with_options(options.clone()).encode(cols, ctx)
+}
+
+/// Compute only the per-row sizes (in bytes) of the row-encoded form for N columns.
+/// Convenience wrapper over [`RowEncoder::row_sizes`].
+pub fn compute_row_sizes(
+    cols: &[ArrayRef],
+    fields: &[RowSortField],
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ArrayRef> {
+    RowEncoder::new(fields.iter().copied()).row_sizes(cols, ctx)
+}
+
+/// Like [`compute_row_sizes`] but takes a prebuilt [`RowEncodingOptions`].
+pub fn compute_row_sizes_with_options(
+    cols: &[ArrayRef],
+    options: &RowEncodingOptions,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<ArrayRef> {
+    RowEncoder::with_options(options.clone()).row_sizes(cols, ctx)
+}
diff --git a/vortex-row/src/lib.rs b/vortex-row/src/lib.rs
new file mode 100644
index 00000000000..b36121f0da2
--- /dev/null
+++ b/vortex-row/src/lib.rs
@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Row-oriented byte encoding for Vortex arrays.
+//!
+//! This crate converts one or more columnar arrays into a single `ListView<u8>` array whose
+//! row byte slices can be compared lexicographically. The byte ordering matches tuple
+//! ordering of the input values under the requested [`RowSortField`] settings, making the
+//! representation useful for sort keys and other row-key operations.
+//!
+//! The public entry points are:
+//! - [`RowEncoder`], the primary API for encoding columns into row bytes.
+//! - [`RowEncoder::row_sizes`], which computes the fixed and variable byte contributions
+//!   without materializing the encoded rows.
+//! - [`convert_columns`] and [`compute_row_sizes`], compatibility helpers around
+//!   [`RowEncoder`].
+//! - [`initialize`], which registers the [`RowSize`] and [`RowEncode`] scalar functions on a
+//!   [`VortexSession`].
+//!
+//! Internally, encoding is split into two scalar functions. [`RowSize`] performs the sizing
+//! pass and classifies fixed-width versus variable-width input columns. [`RowEncode`] uses
+//! those sizes to allocate one contiguous elements buffer, then writes each column's bytes
+//! into the per-row slots from left to right.
+//!
+//! Supported logical types are nulls, booleans, primitive integers and floats, decimals up to
+//! 128 bits, UTF-8 and binary values, structs, and fixed-size lists. Extension, variant,
+//! union, and variable-size list arrays are rejected because this crate does not define an
+//! ordering for them.
+
+mod codec;
+mod encode;
+mod encoder;
+mod options;
+mod size;
+
+#[cfg(test)]
+mod tests;
+
+pub use encode::RowEncode;
+pub use encoder::RowEncoder;
+pub use encoder::compute_row_sizes;
+pub use encoder::compute_row_sizes_with_options;
+pub use encoder::convert_columns;
+pub use encoder::convert_columns_with_options;
+pub use options::RowEncodingOptions;
+pub use options::RowSortField;
+pub use size::RowSize;
+use vortex_array::scalar_fn::session::ScalarFnSessionExt;
+use vortex_session::VortexSession;
+
+/// Register the row-encoding scalar functions ([`RowSize`] and [`RowEncode`]) on the given
+/// session.
+///
+/// Call this during session construction when row encoding must be available through the
+/// expression layer. The direct [`RowEncoder`] API constructs the scalar-function calls
+/// itself and does not require global registration.
+pub fn initialize(session: &VortexSession) {
+    session.scalar_fns().register(RowSize);
+    session.scalar_fns().register(RowEncode);
+}
diff --git a/vortex-row/src/options.rs b/vortex-row/src/options.rs
new file mode 100644
index 00000000000..380c9a3827f
--- /dev/null
+++ b/vortex-row/src/options.rs
@@ -0,0 +1,193 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt::Display;
+use std::fmt::Formatter;
+
+use smallvec::SmallVec;
+
+/// Per-column ordering options for row-oriented encoding.
+///
+/// A `RowSortField` describes how one input column contributes to a row key. Descending order
+/// reverses the encoded value bytes for that column. Null placement is controlled separately,
+/// so nulls keep the requested position relative to non-null values in either direction.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct RowSortField {
+    /// If true, this column sorts in descending order.
+    pub descending: bool,
+    /// If true, nulls sort before non-null values.
+    pub nulls_first: bool,
+}
+
+impl Default for RowSortField {
+    fn default() -> Self {
+        Self::ascending()
+    }
+}
+
+impl Display for RowSortField {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "descending={}, nulls_first={}",
+            self.descending, self.nulls_first
+        )
+    }
+}
+
+impl RowSortField {
+    /// Construct a new `RowSortField` with explicit options.
+    pub const fn new(descending: bool, nulls_first: bool) -> Self {
+        Self {
+            descending,
+            nulls_first,
+        }
+    }
+
+    /// Construct an ascending field with nulls first.
+    pub const fn ascending() -> Self {
+        Self::new(false, true)
+    }
+
+    /// Construct a descending field with nulls first.
+    pub const fn descending() -> Self {
+        Self::new(true, true)
+    }
+
+    /// Return this field with nulls ordered before non-null values.
+    pub const fn nulls_first(mut self) -> Self {
+        self.nulls_first = true;
+        self
+    }
+
+    /// Return this field with nulls ordered after non-null values.
+    pub const fn nulls_last(mut self) -> Self {
+        self.nulls_first = false;
+        self
+    }
+
+    /// Returns the sentinel byte to write for a non-null value.
+    #[inline]
+    pub(crate) fn non_null_sentinel(&self) -> u8 {
+        // Non-null is always 0x01. Null choices are < or > 0x01.
+        0x01
+    }
+
+    /// Returns the sentinel byte to write for a null value.
+    #[inline]
+    pub(crate) fn null_sentinel(&self) -> u8 {
+        if self.nulls_first {
+            // Nulls before non-nulls (smaller byte sorts first).
+            0x00
+        } else {
+            // Nulls after non-nulls (larger byte sorts later).
+            0x02
+        }
+    }
+}
+
+const FIELDS_INLINE: usize = 4;
+
+/// Ordering options for row-oriented encoding.
+///
+/// The options contain one [`RowSortField`] per input column, in the same order as the columns
+/// passed to [`convert_columns`](crate::convert_columns),
+/// [`compute_row_sizes`](crate::compute_row_sizes), [`RowSize`](crate::RowSize), or
+/// [`RowEncode`](crate::RowEncode).
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct RowEncodingOptions {
+    pub(crate) fields: SmallVec<[RowSortField; FIELDS_INLINE]>,
+}
+
+impl RowEncodingOptions {
+    /// Construct a new `RowEncodingOptions` from any iterator of [`RowSortField`]s.
+    pub fn new(fields: impl IntoIterator<Item = RowSortField>) -> Self {
+        Self {
+            fields: fields.into_iter().collect(),
+        }
+    }
+
+    /// Construct default ascending, nulls-first options for `column_count` input columns.
+    pub fn default_for_columns(column_count: usize) -> Self {
+        Self::new(std::iter::repeat_n(RowSortField::default(), column_count))
+    }
+
+    /// Borrow the per-column sort fields.
+    pub fn fields(&self) -> &[RowSortField] {
+        &self.fields
+    }
+
+    /// Return the number of input columns described by these options.
+    pub fn len(&self) -> usize {
+        self.fields.len()
+    }
+
+    /// Return true when the options do not describe any input columns.
+    pub fn is_empty(&self) -> bool {
+        self.fields.is_empty()
+    }
+}
+
+impl FromIterator<RowSortField> for RowEncodingOptions {
+    fn from_iter<T: IntoIterator<Item = RowSortField>>(iter: T) -> Self {
+        Self::new(iter)
+    }
+}
+
+impl Display for RowEncodingOptions {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "[")?;
+        for (i, field) in self.fields.iter().enumerate() {
+            if i > 0 {
+                write!(f, ", ")?;
+            }
+            write!(f, "{}", field)?;
+        }
+        write!(f, "]")
+    }
+}
+
+/// Serialize a [`RowEncodingOptions`] to a compact byte vector: 4-byte LE length followed by
+/// `2 * len` bytes (descending + nulls_first booleans for each field).
+pub(crate) fn serialize_row_encoding_options(opts: &RowEncodingOptions) -> Vec<u8> {
+    use vortex_error::VortexExpect;
+    let n =
+        u32::try_from(opts.fields.len()).vortex_expect("RowEncodingOptions length must fit in u32");
+    let mut out = Vec::with_capacity(4 + 2 * opts.fields.len());
+    out.extend_from_slice(&n.to_le_bytes());
+    for f in &opts.fields {
+        out.push(u8::from(f.descending));
+        out.push(u8::from(f.nulls_first));
+    }
+    out
+}
+
+/// Deserialize a [`RowEncodingOptions`] produced by [`serialize_row_encoding_options`].
+pub(crate) fn deserialize_row_encoding_options(
+    bytes: &[u8],
+) -> vortex_error::VortexResult<RowEncodingOptions> {
+    if bytes.len() < 4 {
+        vortex_error::vortex_bail!(
+            "RowEncodingOptions metadata must contain a 4-byte length prefix"
+        );
+    }
+    let n = u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]) as usize;
+    let expected = 4 + 2 * n;
+    if bytes.len() != expected {
+        vortex_error::vortex_bail!(
+            "RowEncodingOptions metadata wrong size: got {}, expected {}",
+            bytes.len(),
+            expected
+        );
+    }
+    let mut fields: SmallVec<[RowSortField; FIELDS_INLINE]> = SmallVec::with_capacity(n);
+    let mut i = 4;
+    for _ in 0..n {
+        fields.push(RowSortField {
+            descending: bytes[i] != 0,
+            nulls_first: bytes[i + 1] != 0,
+        });
+        i += 2;
+    }
+    Ok(RowEncodingOptions { fields })
+}
diff --git a/vortex-row/src/size.rs b/vortex-row/src/size.rs
new file mode 100644
index 00000000000..6636c4e9f34
--- /dev/null
+++ b/vortex-row/src/size.rs
@@ -0,0 +1,252 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! `RowSize` variadic scalar function: aggregate per-row byte sizes for N input columns.
+
+use std::sync::Arc;
+
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::ExecutionCtx;
+use vortex_array::IntoArray;
+use vortex_array::arrays::ConstantArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::StructArray;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::FieldName;
+use vortex_array::dtype::FieldNames;
+use vortex_array::dtype::Nullability;
+use vortex_array::dtype::PType;
+use vortex_array::dtype::StructFields;
+use vortex_array::scalar::Scalar;
+use vortex_array::scalar_fn::Arity;
+use vortex_array::scalar_fn::ChildName;
+use vortex_array::scalar_fn::ExecutionArgs;
+use vortex_array::scalar_fn::ScalarFnId;
+use vortex_array::scalar_fn::ScalarFnVTable;
+use vortex_array::validity::Validity;
+use vortex_buffer::Buffer;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_session::VortexSession;
+
+use crate::codec;
+use crate::codec::RowWidth;
+use crate::options::RowEncodingOptions;
+use crate::options::deserialize_row_encoding_options;
+use crate::options::serialize_row_encoding_options;
+
+/// Classification of a single input column for the size pass.
+///
+/// Tracks each column's within-row byte offset (the constant prefix from all preceding
+/// fixed-width columns) and, for fixed columns, whether any variable-length column has
+/// appeared yet — the encode pass uses this to choose between the arithmetic-write fast
+/// path (no varlen before this column, so the within-row position is constant per row) and
+/// the cursor-write path.
+#[derive(Clone, Copy, Debug)]
+pub(crate) enum ColKind {
+    /// Fixed-width column. `prefix` is the within-row byte offset of this column's first
+    /// byte. When `before_varlen` is true no variable-length column precedes this one, so the
+    /// within-row offset is constant for every row.
+    Fixed { prefix: u32, before_varlen: bool },
+    /// Column has variable per-row width. `fixed_prefix` is the sum of widths of all
+    /// preceding fixed columns; the contribution of earlier varlen columns is added per row.
+    Variable { fixed_prefix: u32 },
+}
+
+/// Result of the size pass: enough information for both [`RowSize::execute`] and the
+/// downstream [`RowEncode`](super::encode::RowEncode) pipeline.
+///
+/// `columns` holds the canonicalized form of each input so the encode pass can write bytes
+/// without re-decoding — a single canonicalization per column is shared between size and
+/// encode.
+pub(crate) struct SizePassResult {
+    pub fixed_per_row: u32,
+    pub var_lengths: Option<Vec<u32>>,
+    pub col_kinds: Vec<ColKind>,
+    pub first_varlen_idx: Option<usize>,
+    pub columns: Vec<Canonical>,
+}
+
+/// Walk N input columns once, classifying each as fixed-width or variable-length and
+/// accumulating per-row size contributions.
+///
+/// Fixed-width columns contribute a single scalar increment to `fixed_per_row`; they do
+/// not touch `var_lengths`. Variable-length columns add per-row contributions into the
+/// lazily-allocated `var_lengths` vec via `dispatch_size`.
+///
+/// This is shared by [`RowSize::execute`] (which wraps the result into a
+/// `Struct { fixed, var }`) and the [`RowEncode`](super::encode::RowEncode) pipeline
+/// (which reuses the canonicalized columns for the encode pass).
+pub(crate) fn compute_sizes(
+    options: &RowEncodingOptions,
+    args: &dyn ExecutionArgs,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<SizePassResult> {
+    let n_inputs = args.num_inputs();
+    if n_inputs == 0 {
+        vortex_bail!("at least one input column is required");
+    }
+    if options.len() != n_inputs {
+        vortex_bail!(
+            "options len ({}) does not match num_inputs ({})",
+            options.len(),
+            n_inputs
+        );
+    }
+    let nrows = args.row_count();
+
+    let mut columns: Vec<Canonical> = Vec::with_capacity(n_inputs);
+    let mut col_kinds: Vec<ColKind> = Vec::with_capacity(n_inputs);
+    let mut fixed_per_row: u32 = 0;
+    let mut var_lengths: Option<Vec<u32>> = None;
+    let mut first_varlen_idx: Option<usize> = None;
+    let mut running_fixed_prefix: u32 = 0;
+
+    for i in 0..n_inputs {
+        let col = args.get(i)?;
+        if col.len() != nrows {
+            vortex_bail!(
+                "column {} has length {} but expected {}",
+                i,
+                col.len(),
+                nrows
+            );
+        }
+        let width = codec::row_width_for_dtype(col.dtype())?;
+        // Canonicalize once and reuse for both sizing (variable columns) and encoding.
+        let canonical = col.execute::<Canonical>(ctx)?;
+        match width {
+            RowWidth::Fixed(w) => {
+                col_kinds.push(ColKind::Fixed {
+                    prefix: running_fixed_prefix,
+                    before_varlen: first_varlen_idx.is_none(),
+                });
+                let overflow =
+                    || vortex_error::vortex_err!("per-row fixed width overflows u32 at column {i}");
+                fixed_per_row = fixed_per_row.checked_add(w).ok_or_else(overflow)?;
+                running_fixed_prefix = running_fixed_prefix.checked_add(w).ok_or_else(overflow)?;
+            }
+            RowWidth::Variable => {
+                if first_varlen_idx.is_none() {
+                    first_varlen_idx = Some(i);
+                }
+                let v = var_lengths.get_or_insert_with(|| vec![0u32; nrows]);
+                codec::field_size(&canonical, options.fields[i], v, ctx)?;
+                col_kinds.push(ColKind::Variable {
+                    fixed_prefix: running_fixed_prefix,
+                });
+            }
+        }
+        columns.push(canonical);
+    }
+
+    Ok(SizePassResult {
+        fixed_per_row,
+        var_lengths,
+        col_kinds,
+        first_varlen_idx,
+        columns,
+    })
+}
+
+/// Variadic scalar function that, given N input columns and per-column
+/// [`RowSortField`](crate::RowSortField)s,
+/// returns a `Struct { fixed: U32, var: U32 }` array of per-row byte sizes for the
+/// row-oriented encoding produced by [`RowEncode`](super::encode::RowEncode).
+///
+/// The `fixed` field is always a [`ConstantArray`] holding the sum of the per-column
+/// constant widths of fixed-width inputs (sentinel + value bytes). The `var` field is a
+/// `ConstantArray(0)` when there are no variable-length input columns, and a
+/// [`PrimitiveArray<u32>`] of per-row varlen-byte sums otherwise.
+///
+/// The total per-row byte size is `fixed + var`.
+///
+/// This scalar function is public for session registration and row-encoding work.
+/// Most callers should use [`RowEncoder::row_sizes`](crate::RowEncoder::row_sizes) rather
+/// than invoking the scalar function directly.
+#[derive(Clone, Debug)]
+pub struct RowSize;
+
+/// Returns the [`FieldNames`] used by the [`RowSize`] output struct.
+pub(crate) fn row_size_field_names() -> FieldNames {
+    FieldNames::from([FieldName::from("fixed"), FieldName::from("var")])
+}
+
+/// Returns the output [`DType`] of [`RowSize`].
+pub(crate) fn row_size_struct_dtype() -> DType {
+    DType::Struct(
+        StructFields::new(
+            row_size_field_names(),
+            vec![
+                DType::Primitive(PType::U32, Nullability::NonNullable),
+                DType::Primitive(PType::U32, Nullability::NonNullable),
+            ],
+        ),
+        Nullability::NonNullable,
+    )
+}
+
+impl ScalarFnVTable for RowSize {
+    type Options = RowEncodingOptions;
+
+    fn id(&self) -> ScalarFnId {
+        ScalarFnId::from("vortex.row_size")
+    }
+
+    fn serialize(&self, options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
+        Ok(Some(serialize_row_encoding_options(options)))
+    }
+
+    fn deserialize(
+        &self,
+        metadata: &[u8],
+        _session: &VortexSession,
+    ) -> VortexResult<Self::Options> {
+        deserialize_row_encoding_options(metadata)
+    }
+
+    fn arity(&self, _options: &Self::Options) -> Arity {
+        Arity::Variadic { min: 1, max: None }
+    }
+
+    fn child_name(&self, _options: &Self::Options, child_idx: usize) -> ChildName {
+        ChildName::from(Arc::from(format!("col_{}", child_idx)))
+    }
+
+    fn return_dtype(&self, _options: &Self::Options, _args: &[DType]) -> VortexResult<DType> {
+        Ok(row_size_struct_dtype())
+    }
+
+    fn execute(
+        &self,
+        options: &Self::Options,
+        args: &dyn ExecutionArgs,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<ArrayRef> {
+        let nrows = args.row_count();
+        let result = compute_sizes(options, args, ctx)?;
+        let fixed_array =
+            ConstantArray::new(Scalar::from(result.fixed_per_row), nrows).into_array();
+        let var_array = match result.var_lengths {
+            Some(v) => PrimitiveArray::new(Buffer::<u32>::copy_from(&v), Validity::NonNullable)
+                .into_array(),
+            None => ConstantArray::new(Scalar::from(0u32), nrows).into_array(),
+        };
+        Ok(StructArray::try_new(
+            row_size_field_names(),
+            vec![fixed_array, var_array],
+            nrows,
+            Validity::NonNullable,
+        )?
+        .into_array())
+    }
+
+    fn is_null_sensitive(&self, _options: &Self::Options) -> bool {
+        true
+    }
+
+    fn is_fallible(&self, _options: &Self::Options) -> bool {
+        false
+    }
+}
diff --git a/vortex-row/src/tests.rs b/vortex-row/src/tests.rs
new file mode 100644
index 00000000000..5c85c911154
--- /dev/null
+++ b/vortex-row/src/tests.rs
@@ -0,0 +1,615 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Tests for the row encoder.
+
+use std::f64::consts::PI;
+
+use rstest::rstest;
+use vortex_array::IntoArray;
+use vortex_array::LEGACY_SESSION;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::BoolArray;
+use vortex_array::arrays::ExtensionArray;
+use vortex_array::arrays::ListViewArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::StructArray;
+use vortex_array::arrays::VarBinViewArray;
+use vortex_array::arrays::listview::ListViewArrayExt;
+use vortex_array::dtype::Nullability;
+use vortex_array::extension::datetime::Date;
+use vortex_array::extension::datetime::TimeUnit;
+use vortex_error::VortexResult;
+
+use crate::RowEncoder;
+use crate::RowEncodingOptions;
+use crate::RowSortField;
+use crate::compute_row_sizes_with_options;
+use crate::convert_columns;
+use crate::convert_columns_with_options;
+
+fn collect_row_bytes(array: &ListViewArray) -> Vec<Vec<u8>> {
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let nrows = array.len();
+    (0..nrows)
+        .map(|i| {
+            let slice = array.list_elements_at(i).unwrap();
+            let p = slice.execute::<PrimitiveArray>(&mut ctx).unwrap();
+            p.as_slice::<u8>().to_vec()
+        })
+        .collect()
+}
+
+/// Encode each column independently, sort the resulting row bytes, and check the permutation
+/// matches the natural sort order of `values`.
+fn assert_sort_order_i64(values: Vec<i64>, descending: bool) -> VortexResult<()> {
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let col = PrimitiveArray::from_iter(values.clone()).into_array();
+    let field = RowSortField::new(descending, true);
+    let encoded = convert_columns(&[col], &[field], &mut ctx)?;
+    let rows = collect_row_bytes(&encoded);
+
+    // Build expected permutation: sort values naturally then compare to bytes-sorted order.
+    let mut idx: Vec<usize> = (0..values.len()).collect();
+    if descending {
+        idx.sort_by(|a, b| values[*b].cmp(&values[*a]));
+    } else {
+        idx.sort_by(|a, b| values[*a].cmp(&values[*b]));
+    }
+    let expected_order: Vec<Vec<u8>> = idx.iter().map(|&i| rows[i].clone()).collect();
+
+    let mut sorted = rows;
+    sorted.sort();
+    assert_eq!(
+        sorted, expected_order,
+        "Row-encoded bytes do not match natural sort order"
+    );
+    Ok(())
+}
+
+#[rstest]
+#[case::ascending(false)]
+#[case::descending(true)]
+fn primitive_i64_roundtrip(#[case] descending: bool) -> VortexResult<()> {
+    let values: Vec<i64> = vec![-5, 0, 5, i64::MIN, i64::MAX, 7, -7, 1];
+    assert_sort_order_i64(values, descending)
+}
+
+#[test]
+fn primitive_u32_sort_order() -> VortexResult<()> {
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let values: Vec<u32> = vec![0, 1, 100, u32::MAX, 42, 17];
+    let col = PrimitiveArray::from_iter(values.clone()).into_array();
+    let encoded = convert_columns(&[col], &[RowSortField::default()], &mut ctx)?;
+    let rows = collect_row_bytes(&encoded);
+
+    let mut sorted_rows = rows.clone();
+    sorted_rows.sort();
+
+    let mut sorted_idx: Vec<usize> = (0..values.len()).collect();
+    sorted_idx.sort_by(|a, b| values[*a].cmp(&values[*b]));
+    let expected: Vec<Vec<u8>> = sorted_idx.iter().map(|&i| rows[i].clone()).collect();
+    assert_eq!(sorted_rows, expected);
+    Ok(())
+}
+
+#[test]
+fn reject_temporal_extension_dtype_early() -> VortexResult<()> {
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let storage = PrimitiveArray::from_iter([2i32, -1, 0, 7]).into_array();
+    let ext_dtype = Date::new(TimeUnit::Days, Nullability::NonNullable).erased();
+    let col = ExtensionArray::new(ext_dtype, storage).into_array();
+
+    let err = convert_columns(&[col], &[RowSortField::ascending()], &mut ctx)
+        .expect_err("temporal extensions should be rejected");
+    assert!(
+        err.to_string().contains("Extension arrays yet"),
+        "expected error mentioning unsupported Extension arrays, got: {err}"
+    );
+    Ok(())
+}
+
+#[test]
+fn reject_nested_temporal_extension_dtype_early() -> VortexResult<()> {
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let storage = PrimitiveArray::from_iter([2i32, -1, 0, 7]).into_array();
+    let ext_dtype = Date::new(TimeUnit::Days, Nullability::NonNullable).erased();
+    let date_col = ExtensionArray::new(ext_dtype, storage).into_array();
+    let tag_col = VarBinViewArray::from_iter_str(["d", "b", "c", "a"]).into_array();
+    let struct_col =
+        StructArray::from_fields(&[("date", date_col), ("tag", tag_col)])?.into_array();
+
+    let err = convert_columns(&[struct_col], &[RowSortField::ascending()], &mut ctx)
+        .expect_err("nested temporal extensions should be rejected");
+    assert!(
+        err.to_string().contains("Extension arrays yet"),
+        "expected error mentioning unsupported Extension arrays, got: {err}"
+    );
+    Ok(())
+}
+
+#[test]
+fn primitive_f64_sort_order() -> VortexResult<()> {
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    // We use IEEE total-ordering semantics: -0.0 < +0.0 in the byte encoding (matches
+    // `arrow-row`). Avoid -0.0 in the natural-order baseline since partial_cmp says
+    // -0.0 == 0.0.
+    let values: Vec<f64> = vec![-1.5, 0.0, 1.5, f64::INFINITY, f64::NEG_INFINITY, PI];
+    let col = PrimitiveArray::from_iter(values.clone()).into_array();
+    let encoded = convert_columns(&[col], &[RowSortField::default()], &mut ctx)?;
+    let rows = collect_row_bytes(&encoded);
+
+    let mut sorted_rows = rows.clone();
+    sorted_rows.sort();
+
+    let mut sorted_idx: Vec<usize> = (0..values.len()).collect();
+    sorted_idx.sort_by(|a, b| values[*a].partial_cmp(&values[*b]).unwrap());
+    let expected: Vec<Vec<u8>> = sorted_idx.iter().map(|&i| rows[i].clone()).collect();
+    assert_eq!(sorted_rows, expected);
+    Ok(())
+}
+
+#[test]
+fn bool_sort_order() -> VortexResult<()> {
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let col = BoolArray::from_iter([true, false, true, false]).into_array();
+    let encoded = convert_columns(&[col], &[RowSortField::default()], &mut ctx)?;
+    let rows = collect_row_bytes(&encoded);
+
+    let mut sorted = rows.clone();
+    sorted.sort();
+    // false rows come first (2x), true rows after (2x)
+    assert_eq!(sorted[0], rows[1]);
+    assert_eq!(sorted[1], rows[3]);
+    assert_eq!(sorted[2], rows[0]);
+    assert_eq!(sorted[3], rows[2]);
+    Ok(())
+}
+
+#[test]
+fn utf8_sort_order() -> VortexResult<()> {
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let values = vec![
+        "banana",
+        "apple",
+        "",
+        "cherry",
+        "ban",
+        "banana_loaf_for_test",
+    ];
+    let col = VarBinViewArray::from_iter_str(values.clone()).into_array();
+    let encoded = convert_columns(&[col], &[RowSortField::default()], &mut ctx)?;
+    let rows = collect_row_bytes(&encoded);
+
+    let mut sorted = rows.clone();
+    sorted.sort();
+
+    let mut sorted_idx: Vec<usize> = (0..values.len()).collect();
+    sorted_idx.sort_by(|a, b| values[*a].cmp(values[*b]));
+    let expected: Vec<Vec<u8>> = sorted_idx.iter().map(|&i| rows[i].clone()).collect();
+    assert_eq!(sorted, expected);
+    Ok(())
+}
+
+#[test]
+fn multi_column_sort() -> VortexResult<()> {
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let ints: Vec<i32> = vec![1, 2, 1, 2, 1, 3];
+    let strs = vec!["b", "a", "a", "b", "c", "z"];
+    let col0 = PrimitiveArray::from_iter(ints.clone()).into_array();
+    let col1 = VarBinViewArray::from_iter_str(strs.clone()).into_array();
+    let encoded = convert_columns(
+        &[col0, col1],
+        &[RowSortField::default(), RowSortField::default()],
+        &mut ctx,
+    )?;
+    let rows = collect_row_bytes(&encoded);
+
+    let mut sorted = rows.clone();
+    sorted.sort();
+    let mut idx: Vec<usize> = (0..ints.len()).collect();
+    idx.sort_by(|a, b| ints[*a].cmp(&ints[*b]).then_with(|| strs[*a].cmp(strs[*b])));
+    let expected: Vec<Vec<u8>> = idx.iter().map(|&i| rows[i].clone()).collect();
+    assert_eq!(sorted, expected);
+    Ok(())
+}
+
+#[test]
+fn nulls_first_and_last() -> VortexResult<()> {
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let values: Vec<Option<i32>> = vec![Some(5), None, Some(1), None, Some(3)];
+    let col = PrimitiveArray::from_option_iter(values.clone()).into_array();
+
+    // nulls_first=true
+    let encoded = convert_columns(
+        std::slice::from_ref(&col),
+        &[RowSortField::ascending()],
+        &mut ctx,
+    )?;
+    let rows = collect_row_bytes(&encoded);
+    let mut sorted = rows;
+    sorted.sort();
+    // The first two sorted entries should be nulls
+    let null_count = values.iter().filter(|v| v.is_none()).count();
+    for i in 0..null_count {
+        // a null encoded row begins with 0x00
+        assert_eq!(sorted[i][0], 0x00);
+    }
+    // nulls_first=false
+    let encoded = convert_columns(&[col], &[RowSortField::ascending().nulls_last()], &mut ctx)?;
+    let rows = collect_row_bytes(&encoded);
+    let mut sorted = rows;
+    sorted.sort();
+    // The last two sorted entries should be nulls
+    for i in 0..null_count {
+        let pos = sorted.len() - 1 - i;
+        assert_eq!(sorted[pos][0], 0x02);
+    }
+    Ok(())
+}
+
+#[test]
+fn reusable_options_helpers() -> VortexResult<()> {
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let options = RowEncodingOptions::new([RowSortField::descending().nulls_last()]);
+    assert_eq!(options.len(), 1);
+    assert!(!options.is_empty());
+    assert_eq!(
+        options.fields(),
+        &[RowSortField {
+            descending: true,
+            nulls_first: false
+        }]
+    );
+
+    let col = PrimitiveArray::from_iter([1i32, 2, 3]).into_array();
+    let encoder = RowEncoder::with_options(options.clone());
+    assert_eq!(encoder.options(), Some(&options));
+
+    let encoded = encoder.encode(std::slice::from_ref(&col), &mut ctx)?;
+    assert_eq!(encoded.len(), 3);
+
+    let sizes = encoder.row_sizes(std::slice::from_ref(&col), &mut ctx)?;
+    assert_eq!(sizes.len(), 3);
+
+    let encoded = convert_columns_with_options(std::slice::from_ref(&col), &options, &mut ctx)?;
+    assert_eq!(encoded.len(), 3);
+
+    let sizes = compute_row_sizes_with_options(std::slice::from_ref(&col), &options, &mut ctx)?;
+    assert_eq!(sizes.len(), 3);
+    Ok(())
+}
+
+#[test]
+fn row_encoder_new_accepts_sort_fields() -> VortexResult<()> {
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let encoder = RowEncoder::new([RowSortField::ascending()]);
+    let col = PrimitiveArray::from_iter([1i32, 2, 3]).into_array();
+
+    let encoded = encoder.encode(std::slice::from_ref(&col), &mut ctx)?;
+    assert_eq!(encoded.len(), 3);
+    Ok(())
+}
+
+#[test]
+fn default_row_encoder_uses_default_fields() -> VortexResult<()> {
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let col0 = PrimitiveArray::from_iter([1i32, 2, 3]).into_array();
+    let col1 = PrimitiveArray::from_iter([4i32, 5, 6]).into_array();
+
+    let encoded = RowEncoder::default().encode(&[col0, col1], &mut ctx)?;
+    assert_eq!(encoded.len(), 3);
+    Ok(())
+}
+
+#[test]
+fn struct_sort_order() -> VortexResult<()> {
+    use vortex_array::arrays::StructArray;
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let ids: Vec<i64> = vec![3, 1, 3, 1, 2];
+    let names = vec!["b", "a", "a", "b", "z"];
+    let id_arr = PrimitiveArray::from_iter(ids.clone()).into_array();
+    let name_arr = VarBinViewArray::from_iter_str(names.clone()).into_array();
+    let struct_arr = StructArray::from_fields(&[("id", id_arr), ("name", name_arr)])?.into_array();
+
+    let encoded = convert_columns(&[struct_arr], &[RowSortField::default()], &mut ctx)?;
+    let rows = collect_row_bytes(&encoded);
+
+    let mut sorted = rows.clone();
+    sorted.sort();
+    let mut idx: Vec<usize> = (0..ids.len()).collect();
+    idx.sort_by(|a, b| ids[*a].cmp(&ids[*b]).then_with(|| names[*a].cmp(names[*b])));
+    let expected: Vec<Vec<u8>> = idx.iter().map(|&i| rows[i].clone()).collect();
+    assert_eq!(sorted, expected);
+    Ok(())
+}
+
+#[test]
+fn row_size_struct_shape() -> VortexResult<()> {
+    use vortex_array::arrays::Constant;
+    use vortex_array::arrays::StructArray;
+    use vortex_array::arrays::struct_::StructArrayExt;
+
+    use crate::compute_row_sizes;
+
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let ints: Vec<i32> = vec![1, 2, 3, 4, 5];
+    let strs = vec!["a", "bb", "ccc", "", "eeeee"];
+    let col0 = PrimitiveArray::from_iter(ints).into_array();
+    let col1 = VarBinViewArray::from_iter_str(strs).into_array();
+
+    let sizes = compute_row_sizes(
+        &[col0, col1],
+        &[RowSortField::default(), RowSortField::default()],
+        &mut ctx,
+    )?;
+    // Shape must be Struct { fixed, var }
+    let struct_arr = sizes.execute::<StructArray>(&mut ctx)?;
+    assert_eq!(struct_arr.struct_fields().nfields(), 2);
+    let fixed = struct_arr.unmasked_field(0);
+    let var = struct_arr.unmasked_field(1);
+
+    // `fixed` must be ConstantArray with value = encoded i32 width = 1 + 4 = 5.
+    let fixed_const = fixed
+        .as_opt::<Constant>()
+        .expect("fixed field should be a ConstantArray");
+    assert_eq!(
+        fixed_const.scalar(),
+        &vortex_array::scalar::Scalar::from(5u32),
+        "fixed scalar should be encoded primitive i32 width"
+    );
+
+    // `var` must be a PrimitiveArray<u32>, since we have a varlen column.
+    let var_prim = var.clone().execute::<PrimitiveArray>(&mut ctx)?;
+    let v: &[u32] = var_prim.as_slice();
+    assert_eq!(v.len(), 5);
+    // empty string: just the empty sentinel (1 byte); null or non-empty:
+    // sentinel(1) + 33 bytes (single block).
+    let expected: Vec<u32> = vec![34, 34, 34, 1, 34];
+    assert_eq!(v, expected.as_slice());
+    Ok(())
+}
+
+#[test]
+fn single_buffer_invariant() -> VortexResult<()> {
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    // Encoded rows here are all > 12 bytes, forcing the Ref-view path that points back into
+    // the shared data buffer.
+    let nrows = 64usize;
+    let primitives: Vec<i64> = (0..nrows as i64).collect();
+    let strings: Vec<String> = (0..nrows)
+        .map(|i| format!("row_{}_with_padding", i))
+        .collect();
+    let col0 = PrimitiveArray::from_iter(primitives).into_array();
+    let col1 = VarBinViewArray::from_iter_str(strings.iter().map(String::as_str)).into_array();
+    let encoded = convert_columns(
+        &[col0, col1],
+        &[RowSortField::default(), RowSortField::default()],
+        &mut ctx,
+    )?;
+
+    let rows = collect_row_bytes(&encoded);
+    let expected_total: usize = rows.iter().map(|r| r.len()).sum();
+
+    // The shared data buffer holds the contiguous concatenation of every row's encoded bytes;
+    // per-row allocations would produce many small buffers instead of one shared buffer.
+    // ListView's elements array is a single contiguous primitive (u8) array; its length
+    // equals the sum of all per-row sizes. A per-row allocation strategy would instead
+    // produce N separate elements arrays or a sparse one.
+    let elements_len = encoded.elements().len();
+    assert_eq!(
+        elements_len, expected_total,
+        "elements buffer size mismatch"
+    );
+    Ok(())
+}
+
+/// Regression: with the previous 2-sentinel varlen scheme, an empty col1 followed by a
+/// non-empty col1 that happened to start with `\0` would corrupt multi-column lex order
+/// because col2's first byte aligned against col1's pad in the longer row. With the
+/// 3-sentinel scheme byte position 0 alone distinguishes empty from non-empty, so column
+/// boundaries always align.
+#[test]
+fn multi_column_varlen_empty_vs_nul_byte_string() -> VortexResult<()> {
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    // col1: empty vs single 0-byte. col2: same int for all rows.
+    let col1 = VarBinViewArray::from_iter_str(["", "\0", "a", "ab"]).into_array();
+    let col2 = PrimitiveArray::from_iter([1i32, 1, 1, 1]).into_array();
+    let encoded = convert_columns(
+        &[col1, col2],
+        &[RowSortField::default(), RowSortField::default()],
+        &mut ctx,
+    )?;
+    let rows = collect_row_bytes(&encoded);
+
+    // Logical natural order of col1: "" < "\0" < "a" < "ab".
+    // Byte sort of the encoded rows must put them in that same order.
+    let sorted_indices_by_bytes = {
+        let mut indices: Vec<usize> = (0..rows.len()).collect();
+        indices.sort_by(|a, b| rows[*a].cmp(&rows[*b]));
+        indices
+    };
+    assert_eq!(
+        sorted_indices_by_bytes,
+        vec![0, 1, 2, 3],
+        "byte sort must match natural col1 order; sorted indices were {:?}",
+        sorted_indices_by_bytes
+    );
+    Ok(())
+}
+
+/// Regression: null col1 must sort distinct from empty col1 even when col2 follows. With
+/// the 3-sentinel scheme null=0x00, empty=0x01 differ at byte 0.
+#[test]
+fn multi_column_varlen_null_vs_empty() -> VortexResult<()> {
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let col1 = VarBinViewArray::from_iter_nullable_str([
+        None::<&str>,
+        Some(""),
+        Some("a"),
+        None,
+        Some(""),
+    ])
+    .into_array();
+    let col2 = PrimitiveArray::from_iter([1i32, 1, 1, 1, 1]).into_array();
+    let encoded = convert_columns(
+        &[col1, col2],
+        &[RowSortField::ascending(), RowSortField::ascending()],
+        &mut ctx,
+    )?;
+    let rows = collect_row_bytes(&encoded);
+
+    // Nulls first, then empties, then non-empties — and all the col2 values are identical
+    // so col1 fully determines the order.
+    // Categorise each row by the leading byte of col1's encoding.
+    let mut buckets: [Vec<usize>; 3] = [Vec::new(), Vec::new(), Vec::new()];
+    for (i, row) in rows.iter().enumerate() {
+        let bucket = match row[0] {
+            0x00 => 0, // null
+            0x01 => 1, // empty
+            0x02 => 2, // non-empty
+            other => panic!("unexpected varlen sentinel: {:#x}", other),
+        };
+        buckets[bucket].push(i);
+    }
+    assert_eq!(buckets[0].len(), 2, "two null col1 rows");
+    assert_eq!(buckets[1].len(), 2, "two empty col1 rows");
+    assert_eq!(buckets[2].len(), 1, "one non-empty col1 row");
+
+    // All null rows must be byte-equal (same col2 value, both col1 null, single sentinel).
+    let null_rows: Vec<&Vec<u8>> = buckets[0].iter().map(|&i| &rows[i]).collect();
+    assert_eq!(
+        null_rows[0], null_rows[1],
+        "null col1 rows must be byte-equal"
+    );
+    // Same for empty.
+    let empty_rows: Vec<&Vec<u8>> = buckets[1].iter().map(|&i| &rows[i]).collect();
+    assert_eq!(
+        empty_rows[0], empty_rows[1],
+        "empty col1 rows must be byte-equal"
+    );
+
+    // Byte sort must group: nulls, empties, non-empties (because leading byte differs).
+    let mut sorted = rows.clone();
+    sorted.sort();
+    assert_eq!(sorted[0][0], 0x00);
+    assert_eq!(sorted[1][0], 0x00);
+    assert_eq!(sorted[2][0], 0x01);
+    assert_eq!(sorted[3][0], 0x01);
+    assert_eq!(sorted[4][0], 0x02);
+    Ok(())
+}
+
+/// Regression: descending varlen must put non-empty before empty (natural "" < "a" inverts
+/// to "a" < "" under descending). The 3-sentinel scheme uses `!empty < !non_empty` so
+/// non-empty's first byte is smaller than empty's first byte.
+#[test]
+fn varlen_descending_empty_vs_non_empty() -> VortexResult<()> {
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let col = VarBinViewArray::from_iter_str(["a", "", "abc"]).into_array();
+    let encoded = convert_columns(&[col], &[RowSortField::descending()], &mut ctx)?;
+    let rows = collect_row_bytes(&encoded);
+
+    // Natural order: "" < "a" < "abc"; descending byte sort: "abc" first, "" last.
+    let mut sorted = rows.clone();
+    sorted.sort();
+    // sorted[0] = encoded("abc"), sorted[1] = encoded("a"), sorted[2] = encoded("")
+    assert_eq!(sorted[0], rows[2], "abc first in descending");
+    assert_eq!(sorted[1], rows[0], "a second");
+    assert_eq!(sorted[2], rows[1], "empty last");
+    Ok(())
+}
+
+/// Regression: two null parent struct rows whose underlying child values differ in length
+/// must still produce byte-equal encodings, because the parent emits a canonical null
+/// body (one null sentinel per variable child) regardless of the underlying values.
+#[test]
+fn null_struct_rows_with_varying_child_lengths_are_byte_equal() -> VortexResult<()> {
+    use vortex_array::arrays::StructArray;
+    use vortex_array::dtype::FieldName;
+    use vortex_array::dtype::FieldNames;
+    use vortex_array::validity::Validity;
+    use vortex_buffer::BitBuffer;
+
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    // Build a nullable struct{name: utf8} where rows 0 and 2 are null but the underlying
+    // child has different length data ("short" vs "much longer text data").
+    let names =
+        VarBinViewArray::from_iter_str(["short", "x", "much longer text data"]).into_array();
+    let field_names = FieldNames::from([FieldName::from("name")]);
+    let bits = BitBuffer::from_iter([false, true, false]);
+    let validity = Validity::from(bits);
+    let struct_arr = StructArray::try_new(field_names, vec![names], 3, validity)?.into_array();
+
+    let encoded = convert_columns(&[struct_arr], &[RowSortField::ascending()], &mut ctx)?;
+    let rows = collect_row_bytes(&encoded);
+    assert_eq!(rows.len(), 3);
+    // Both null parent rows must produce identical bytes despite the divergent children.
+    assert_eq!(
+        rows[0], rows[2],
+        "two null parent struct rows must encode to byte-equal slices"
+    );
+    // And the non-null row's leading sentinel must differ from the null sentinel.
+    assert_ne!(rows[0][0], rows[1][0], "null vs non-null sentinel differs");
+    Ok(())
+}
+
+#[test]
+fn primitive_f32_sort_order() -> VortexResult<()> {
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let values: Vec<f32> = vec![-1.5, 0.0, 1.5, f32::INFINITY, f32::NEG_INFINITY];
+    let col = PrimitiveArray::from_iter(values.clone()).into_array();
+    let encoded = convert_columns(&[col], &[RowSortField::default()], &mut ctx)?;
+    let rows = collect_row_bytes(&encoded);
+    let mut sorted_rows = rows.clone();
+    sorted_rows.sort();
+    let mut sorted_idx: Vec<usize> = (0..values.len()).collect();
+    sorted_idx.sort_by(|a, b| values[*a].partial_cmp(&values[*b]).unwrap());
+    let expected: Vec<Vec<u8>> = sorted_idx.iter().map(|&i| rows[i].clone()).collect();
+    assert_eq!(sorted_rows, expected);
+    Ok(())
+}
+
+#[test]
+fn primitive_f16_sort_order() -> VortexResult<()> {
+    use vortex_array::dtype::half::f16;
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let values: Vec<f16> = vec![
+        f16::from_f32(-1.5),
+        f16::from_f32(0.0),
+        f16::from_f32(1.5),
+        f16::INFINITY,
+        f16::NEG_INFINITY,
+    ];
+    let col = PrimitiveArray::from_iter(values.clone()).into_array();
+    let encoded = convert_columns(&[col], &[RowSortField::default()], &mut ctx)?;
+    let rows = collect_row_bytes(&encoded);
+    let mut sorted_rows = rows.clone();
+    sorted_rows.sort();
+    let mut sorted_idx: Vec<usize> = (0..values.len()).collect();
+    sorted_idx.sort_by(|a, b| values[*a].partial_cmp(&values[*b]).unwrap());
+    let expected: Vec<Vec<u8>> = sorted_idx.iter().map(|&i| rows[i].clone()).collect();
+    assert_eq!(sorted_rows, expected);
+    Ok(())
+}
+
+#[test]
+fn reject_list_dtype_early() {
+    use vortex_array::ArrayRef;
+    use vortex_array::arrays::ListArray;
+    use vortex_array::validity::Validity;
+    use vortex_buffer::buffer;
+
+    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let offsets = PrimitiveArray::new(buffer![0u32, 1, 2], Validity::NonNullable).into_array();
+    let elements = PrimitiveArray::from_iter([10i32, 20]).into_array();
+    let list: ArrayRef = ListArray::try_new(elements, offsets, Validity::NonNullable)
+        .unwrap()
+        .into_array();
+    let err = convert_columns(&[list], &[RowSortField::default()], &mut ctx)
+        .expect_err("List should not be accepted");
+    assert!(
+        err.to_string().contains("List"),
+        "expected error mentioning List, got: {err}"
+    );
+}
diff --git a/vortex-sqllogictest/slt/datafusion/order_pushdown.slt b/vortex-sqllogictest/slt/datafusion/order_pushdown.slt
new file mode 100644
index 00000000000..49ecba8acb5
--- /dev/null
+++ b/vortex-sqllogictest/slt/datafusion/order_pushdown.slt
@@ -0,0 +1,44 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+include ../setup.slt.no
+
+statement ok
+CREATE EXTERNAL TABLE ordered_pushdown (
+    c1 VARCHAR NOT NULL,
+    c2 INT NOT NULL
+)
+STORED AS vortex
+WITH ORDER (c1 ASC)
+LOCATION '$__TEST_DIR__/ordered_pushdown/';
+
+statement ok
+INSERT INTO ordered_pushdown VALUES
+    ('air', 5),
+    ('balloon', 42);
+
+statement ok
+INSERT INTO ordered_pushdown VALUES
+    ('zebra', 5);
+
+statement ok
+INSERT INTO ordered_pushdown VALUES
+    ('texas', 2000),
+    ('alabama', 2000);
+
+query TI
+SELECT c1, c2 FROM ordered_pushdown ORDER BY c1 ASC LIMIT 3;
+----
+air 5
+alabama 2000
+balloon 42
+
+query TT
+EXPLAIN SELECT c1, c2 FROM ordered_pushdown ORDER BY c1 ASC LIMIT 3;
+----
+logical_plan
+01)Sort: ordered_pushdown.c1 ASC NULLS LAST, fetch=3
+02)--TableScan: ordered_pushdown projection=[c1, c2]
+physical_plan
+01)SortPreservingMergeExec: [c1@0 ASC NULLS LAST], fetch=3
+02)--DataSourceExec: file_groups={<slt:ignore>}, projection=[c1, c2], limit=3, output_ordering=[c1@0 ASC NULLS LAST], file_type=vortex
diff --git a/vortex-tensor/Cargo.toml b/vortex-tensor/Cargo.toml
index b0521170e67..a293e604b5b 100644
--- a/vortex-tensor/Cargo.toml
+++ b/vortex-tensor/Cargo.toml
@@ -21,7 +21,6 @@ vortex-array = { workspace = true }
 vortex-buffer = { workspace = true }
 vortex-compressor = { workspace = true }
 vortex-error = { workspace = true }
-vortex-fastlanes = { workspace = true }
 vortex-session = { workspace = true }
 vortex-utils = { workspace = true }
 
diff --git a/vortex-tensor/src/encodings/mod.rs b/vortex-tensor/src/encodings/mod.rs
index 22e57763171..e42a8605096 100644
--- a/vortex-tensor/src/encodings/mod.rs
+++ b/vortex-tensor/src/encodings/mod.rs
@@ -7,4 +7,3 @@
 // pub mod spherical; // Spherical transform on unit-normalized vectors.
 
 pub mod l2_denorm;
-pub mod turboquant;
diff --git a/vortex-tensor/src/encodings/turboquant/centroids.rs b/vortex-tensor/src/encodings/turboquant/centroids.rs
deleted file mode 100644
index ab653de3c35..00000000000
--- a/vortex-tensor/src/encodings/turboquant/centroids.rs
+++ /dev/null
@@ -1,361 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Max-Lloyd centroid computation for TurboQuant scalar quantizers.
-//!
-//! Pre-computes and caches optimal scalar quantizer centroids for the marginal distribution of
-//! coordinates after a random orthogonal transform of a unit-norm vector.
-//!
-//! In high dimensions, each coordinate of a randomly transformed unit vector follows a
-//! distribution proportional to `(1 - x^2)^((d-3)/2)` on `[-1, 1]`, which converges to
-//! `N(0, 1/d)`.
-//!
-//! The Max-Lloyd algorithm finds optimal quantization centroids that minimize MSE for this
-//! distribution.
-//!
-//! Centroids are not stored in TurboQuant arrays. They are deterministically derived from
-//! `(padded_dim, bit_width)` and cached process-locally.
-//!
-//! The centroid model follows the random orthogonal transform marginal used by the TurboQuant
-//! paper. This encoder applies a SORF-style structured transform instead of a dense random Gaussian
-//! or orthogonal matrix, so paper-level error bounds should not be treated as verified for this
-//! implementation without separate empirical validation.
-
-use std::sync::LazyLock;
-
-use vortex_buffer::Buffer;
-use vortex_error::VortexResult;
-use vortex_error::vortex_ensure;
-use vortex_utils::aliases::dash_map::DashMap;
-
-use crate::encodings::turboquant::MAX_BIT_WIDTH;
-use crate::encodings::turboquant::MIN_DIMENSION;
-
-// NB: All of these constants were chosen arbitrarily.
-
-/// The maximum iterations for Max-Lloyd algorithm when computing centroids.
-const MAX_ITERATIONS: usize = 200;
-
-/// The Max-Lloyd convergence threshold for stopping early when computing centroids.
-const CONVERGENCE_EPSILON: f64 = 1e-12;
-
-/// Number of trapezoids used for numerical integration when computing conditional expectations.
-///
-/// The trapezoidal rule evaluates the integrand at `INTEGRATION_TRAPEZOIDS + 1` points.
-const INTEGRATION_TRAPEZOIDS: usize = 1000;
-
-/// Global centroid cache keyed by (dimension, bit_width).
-static CENTROID_CACHE: LazyLock<DashMap<(u32, u8), Buffer<f32>>> = LazyLock::new(DashMap::default);
-
-/// Get or compute cached centroids for the given dimension and bit width.
-///
-/// Returns `2^bit_width` centroids sorted in ascending order, representing optimal scalar
-/// quantization levels for the coordinate distribution after a random orthogonal transform in
-/// `dimension`-dimensional space.
-pub(crate) fn compute_or_get_centroids(dimension: u32, bit_width: u8) -> VortexResult<Buffer<f32>> {
-    vortex_ensure!(
-        (1..=MAX_BIT_WIDTH).contains(&bit_width),
-        "TurboQuant bit_width must be 1-{}, got {bit_width}",
-        MAX_BIT_WIDTH
-    );
-    vortex_ensure!(
-        dimension >= MIN_DIMENSION,
-        "TurboQuant dimension must be >= {}, got {dimension}",
-        MIN_DIMENSION
-    );
-
-    if let Some(centroids) = CENTROID_CACHE.get(&(dimension, bit_width)) {
-        return Ok(centroids.clone());
-    }
-
-    let centroids = max_lloyd_centroids(dimension, bit_width);
-    CENTROID_CACHE.insert((dimension, bit_width), centroids.clone());
-
-    Ok(centroids)
-}
-
-// TODO(connor): It would potentially be more performant if this was modelled as const generic
-// parameters to functions.
-/// Half-integer exponent: represents `int_part + (if has_half { 0.5 } else { 0.0 })`.
-///
-/// The marginal distribution exponent `(d-3)/2` is always an integer (when `d` is odd) or a
-/// half-integer (when `d` is even).
-///
-/// This type makes that invariant explicit and avoids floating-point comparison in the hot path.
-#[derive(Clone, Copy, Debug)]
-struct HalfIntExponent {
-    int_part: i32,
-    has_half: bool,
-}
-
-impl HalfIntExponent {
-    /// Compute `(numerator) / 2` as a half-integer exponent.
-    ///
-    /// `numerator` is `d - 3` where `d` is the dimension (>= 2), so it can be negative.
-    fn from_numerator(numerator: i32) -> Self {
-        // Use Euclidean division to get floor division toward negative infinity.
-        let int_part = numerator.div_euclid(2);
-        let has_half = numerator.rem_euclid(2) != 0;
-        Self { int_part, has_half }
-    }
-}
-
-/// Compute optimal centroids via the Max-Lloyd (Lloyd-Max) algorithm.
-///
-/// Operates on the marginal distribution of a single coordinate of a randomly transformed unit
-/// vector in d dimensions.
-///
-/// The probability distribution function is:
-///   `f(x) = C_d * (1 - x^2)^((d-3)/2)` on `[-1, 1]`
-/// where `C_d` is the normalizing constant.
-///
-/// Centroids are seeded uniformly on `[±sqrt(bit_width) * sigma]` (where `sigma` is the standard
-/// deviation of the normal distribution that hypershere dimension values take, and specifically
-/// `sigma = 1/sqrt(dimension)`) rather than across the full `[-1, 1]`, which strands most of the
-/// centroids in the near-zero-mass tails.
-///
-/// Note that the `sqrt(bit_width)` is mostly empirically derived, we do not have a theoretical
-/// basis for choosing this other than the fact that it seems to produce good results.
-fn max_lloyd_centroids(dimension: u32, bit_width: u8) -> Buffer<f32> {
-    debug_assert!((1..=MAX_BIT_WIDTH).contains(&bit_width));
-    let num_centroids = 1usize << bit_width;
-
-    // For the marginal distribution on [-1, 1], we use the exponent (d-3)/2.
-    let exponent = HalfIntExponent::from_numerator(dimension as i32 - 3);
-
-    // The coordinate marginal concentrates around 0 with this standard deviation.
-    let sigma = 1.0 / f64::from(dimension).sqrt();
-    let init_half = (f64::from(bit_width).sqrt() * sigma).min(1.0);
-
-    // Initialize centroids uniformly on [-init_half, init_half], where the mass lives, so no cell
-    // starts in a zero-mass region and freezes.
-    let mut centroids: Vec<f64> = (0..num_centroids)
-        .map(|idx| -init_half + (2.0 * (idx as f64) + 1.0) * init_half / (num_centroids as f64))
-        .collect();
-
-    let mut boundaries: Vec<f64> = vec![0.0; num_centroids + 1];
-    for _ in 0..MAX_ITERATIONS {
-        // Compute decision boundaries (midpoints between adjacent centroids).
-        boundaries[0] = -1.0;
-        for idx in 0..num_centroids - 1 {
-            boundaries[idx + 1] = (centroids[idx] + centroids[idx + 1]) / 2.0;
-        }
-        boundaries[num_centroids] = 1.0;
-
-        // Update each centroid to the conditional mean within its Voronoi cell.
-        let mut max_change = 0.0f64;
-        for idx in 0..num_centroids {
-            let lo = boundaries[idx];
-            let hi = boundaries[idx + 1];
-            let new_centroid = mean_between_centroids(lo, hi, exponent);
-            max_change = max_change.max((new_centroid - centroids[idx]).abs());
-            centroids[idx] = new_centroid;
-        }
-
-        if max_change < CONVERGENCE_EPSILON {
-            break;
-        }
-    }
-
-    #[expect(
-        clippy::cast_possible_truncation,
-        reason = "all values are in [-1, 1] so this just loses precision"
-    )]
-    centroids.into_iter().map(|val| val as f32).collect()
-}
-
-/// Compute the conditional mean of the coordinate distribution on interval [lo, hi].
-///
-/// Returns `E[X | lo <= X <= hi]` where X has PDF proportional to `(1 - x^2)^exponent` on [-1, 1].
-///
-/// Since there is no closed form for the integrals, we compute this numerically.
-fn mean_between_centroids(lo: f64, hi: f64, exponent: HalfIntExponent) -> f64 {
-    if (hi - lo).abs() < 1e-15 {
-        return (lo + hi) / 2.0;
-    }
-
-    let dx = (hi - lo) / INTEGRATION_TRAPEZOIDS as f64;
-
-    let mut numerator = 0.0;
-    let mut denominator = 0.0;
-
-    for step in 0..=INTEGRATION_TRAPEZOIDS {
-        let x_val = lo + (step as f64) * dx;
-        let weight = pdf_unnormalized(x_val, exponent);
-
-        let trap_weight = if step == 0 || step == INTEGRATION_TRAPEZOIDS {
-            0.5
-        } else {
-            1.0
-        };
-
-        numerator += trap_weight * x_val * weight;
-        denominator += trap_weight * weight;
-    }
-
-    if denominator.abs() < 1e-30 {
-        (lo + hi) / 2.0
-    } else {
-        numerator / denominator
-    }
-}
-
-/// Unnormalized PDF of the coordinate distribution: `(1 - x^2)^exponent`.
-///
-/// Uses `powi` + `sqrt` instead of `powf` for the half-integer exponents that arise from `(d-3)/2`.
-/// This is significantly faster than the general `powf` which goes through
-/// `exp(exponent * ln(base))`.
-fn pdf_unnormalized(x_val: f64, exponent: HalfIntExponent) -> f64 {
-    let base = (1.0 - x_val * x_val).max(0.0);
-
-    if exponent.has_half {
-        // Half-integer exponent: base^(int_part) * sqrt(base).
-        base.powi(exponent.int_part) * base.sqrt()
-    } else {
-        // Integer exponent: use powi directly.
-        base.powi(exponent.int_part)
-    }
-}
-
-/// Precompute decision boundaries (midpoints between adjacent centroids).
-///
-/// For `k` centroids, returns `k-1` boundaries. A value below `boundaries[0]` maps to centroid 0, a
-/// value in `[boundaries[i-1], boundaries[i])` maps to centroid `i`, and a
-/// value `>= boundaries[k-2]` maps to centroid `k-1`.
-pub(crate) fn compute_centroid_boundaries(centroids: &[f32]) -> Vec<f32> {
-    centroids.windows(2).map(|w| (w[0] + w[1]) * 0.5).collect()
-}
-
-/// Find the index of the nearest centroid using precomputed decision boundaries.
-///
-/// `boundaries` must be the output of [`compute_centroid_boundaries`] for the corresponding
-/// centroids. Uses binary search on the midpoints, avoiding distance comparisons
-/// in the inner loop.
-#[inline]
-pub(crate) fn find_nearest_centroid(value: f32, boundaries: &[f32]) -> u8 {
-    debug_assert!(
-        boundaries.windows(2).all(|w| w[0] <= w[1]),
-        "boundaries must be sorted"
-    );
-    debug_assert!(
-        boundaries.len() <= 256, // 1 << 8
-        "too many boundaries"
-    );
-
-    #[expect(
-        clippy::cast_possible_truncation,
-        reason = "num_centroids <= 256 and partition_point will return at most 255"
-    )]
-    (boundaries.partition_point(|&b| b < value) as u8)
-}
-
-#[cfg(test)]
-mod tests {
-    use rstest::rstest;
-    use vortex_error::VortexResult;
-
-    use super::*;
-
-    #[rstest]
-    #[case(128, 1, 2)]
-    #[case(128, 2, 4)]
-    #[case(128, 3, 8)]
-    #[case(128, 4, 16)]
-    #[case(768, 2, 4)]
-    #[case(1536, 3, 8)]
-    fn centroids_have_correct_count(
-        #[case] dim: u32,
-        #[case] bits: u8,
-        #[case] expected: usize,
-    ) -> VortexResult<()> {
-        let centroids = compute_or_get_centroids(dim, bits)?;
-        assert_eq!(centroids.len(), expected);
-        Ok(())
-    }
-
-    #[rstest]
-    #[case(128, 1)]
-    #[case(128, 2)]
-    #[case(128, 3)]
-    #[case(128, 4)]
-    #[case(768, 2)]
-    fn centroids_are_sorted(#[case] dim: u32, #[case] bits: u8) -> VortexResult<()> {
-        let centroids = compute_or_get_centroids(dim, bits)?;
-        for window in centroids.windows(2) {
-            assert!(
-                window[0] < window[1],
-                "centroids not sorted: {:?}",
-                centroids
-            );
-        }
-        Ok(())
-    }
-
-    #[rstest]
-    #[case(128, 1)]
-    #[case(128, 2)]
-    #[case(256, 2)]
-    #[case(768, 2)]
-    fn centroids_are_symmetric(#[case] dim: u32, #[case] bits: u8) -> VortexResult<()> {
-        let centroids = compute_or_get_centroids(dim, bits)?;
-        let count = centroids.len();
-        for idx in 0..count / 2 {
-            let diff = (centroids[idx] + centroids[count - 1 - idx]).abs();
-            assert!(
-                diff < 1e-5,
-                "centroids not symmetric: c[{idx}]={}, c[{}]={}",
-                centroids[idx],
-                count - 1 - idx,
-                centroids[count - 1 - idx]
-            );
-        }
-        Ok(())
-    }
-
-    #[rstest]
-    #[case(128, 1)]
-    #[case(128, 4)]
-    fn centroids_within_bounds(#[case] dim: u32, #[case] bits: u8) -> VortexResult<()> {
-        let centroids = compute_or_get_centroids(dim, bits)?;
-        for &val in centroids.iter() {
-            assert!(
-                (-1.0..=1.0).contains(&val),
-                "centroid out of [-1, 1]: {val}",
-            );
-        }
-        Ok(())
-    }
-
-    #[test]
-    fn centroids_cached() -> VortexResult<()> {
-        let c1 = compute_or_get_centroids(128, 2)?;
-        let c2 = compute_or_get_centroids(128, 2)?;
-        assert_eq!(c1, c2);
-        Ok(())
-    }
-
-    #[test]
-    fn find_nearest_basic() -> VortexResult<()> {
-        let centroids = compute_or_get_centroids(128, 2)?;
-        let boundaries = compute_centroid_boundaries(&centroids);
-        assert_eq!(find_nearest_centroid(-1.0, &boundaries), 0);
-
-        #[expect(clippy::cast_possible_truncation)]
-        let last_idx = (centroids.len() - 1) as u8;
-        assert_eq!(find_nearest_centroid(1.0, &boundaries), last_idx);
-        for (idx, &cv) in centroids.iter().enumerate() {
-            #[expect(clippy::cast_possible_truncation)]
-            let expected = idx as u8;
-            assert_eq!(find_nearest_centroid(cv, &boundaries), expected);
-        }
-        Ok(())
-    }
-
-    #[test]
-    fn rejects_invalid_params() {
-        assert!(compute_or_get_centroids(128, 0).is_err());
-        assert!(compute_or_get_centroids(128, 9).is_err());
-        assert!(compute_or_get_centroids(1, 2).is_err());
-        assert!(compute_or_get_centroids(127, 2).is_err());
-    }
-}
diff --git a/vortex-tensor/src/encodings/turboquant/compress.rs b/vortex-tensor/src/encodings/turboquant/compress.rs
deleted file mode 100644
index e656ba18822..00000000000
--- a/vortex-tensor/src/encodings/turboquant/compress.rs
+++ /dev/null
@@ -1,270 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! TurboQuant encoding (quantization) logic.
-//!
-//! The input to [`turboquant_encode`] must be a non-nullable [`Vector`](crate::vector::Vector)
-//! extension array whose rows are already L2-normalized (unit norm). Normalization is handled
-//! externally by [`normalize_as_l2_denorm`](crate::scalar_fns::l2_denorm::normalize_as_l2_denorm),
-//! which the [`TurboQuantScheme`] calls before invoking this function.
-//!
-//! [`TurboQuantScheme`]: crate::encodings::turboquant::TurboQuantScheme
-
-use vortex_array::ArrayRef;
-use vortex_array::ArrayView;
-use vortex_array::ExecutionCtx;
-use vortex_array::IntoArray;
-use vortex_array::arrays::Extension;
-use vortex_array::arrays::FixedSizeListArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::dict::DictArray;
-use vortex_array::arrays::extension::ExtensionArrayExt;
-use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
-use vortex_array::arrays::scalar_fn::ScalarFnArrayExt;
-use vortex_array::dtype::Nullability;
-use vortex_array::validity::Validity;
-use vortex_buffer::Buffer;
-use vortex_buffer::BufferMut;
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
-use vortex_error::vortex_ensure;
-
-use crate::encodings::turboquant::MAX_BIT_WIDTH;
-use crate::encodings::turboquant::MIN_DIMENSION;
-use crate::encodings::turboquant::centroids::compute_centroid_boundaries;
-use crate::encodings::turboquant::centroids::compute_or_get_centroids;
-use crate::encodings::turboquant::centroids::find_nearest_centroid;
-use crate::scalar_fns::l2_denorm::L2Denorm;
-use crate::scalar_fns::l2_denorm::normalize_as_l2_denorm;
-use crate::scalar_fns::sorf_transform::SorfMatrix;
-use crate::scalar_fns::sorf_transform::SorfOptions;
-use crate::scalar_fns::sorf_transform::SorfTransform;
-use crate::types::vector::AnyVector;
-use crate::types::vector::Vector;
-use crate::utils::cast_to_f32;
-
-/// Configuration for TurboQuant encoding.
-#[derive(Clone, Debug)]
-pub struct TurboQuantConfig {
-    /// Bits per coordinate (1-8).
-    pub bit_width: u8,
-    /// Seed for the rotation matrix.
-    pub seed: u64,
-    /// Number of sign-diagonal + WHT rounds in the structured rotation (default 3).
-    pub num_rounds: u8,
-}
-
-impl Default for TurboQuantConfig {
-    fn default() -> Self {
-        Self {
-            bit_width: MAX_BIT_WIDTH,
-            seed: 42,
-            num_rounds: 3,
-        }
-    }
-}
-
-/// Apply the full TurboQuant compression pipeline to a [`Vector`](crate::vector::Vector)
-/// extension array: normalize the rows via [`normalize_as_l2_denorm`], quantize the normalized
-/// child via [`turboquant_encode_unchecked`], and reattach the stored norms as the outer
-/// [`L2Denorm`] wrapper.
-///
-/// The returned array has the canonical TurboQuant shape:
-///
-/// ```text
-/// ScalarFnArray(L2Denorm, [
-///     ScalarFnArray(SorfTransform, [FSL(Dict(codes, centroids))]),
-///     norms,
-/// ])
-/// ```
-///
-/// # Errors
-///
-/// Returns an error if `input` is not a tensor-like extension array, if normalization fails, or
-/// if [`turboquant_encode_unchecked`] rejects the input shape.
-pub fn turboquant_encode(
-    input: ArrayRef,
-    config: &TurboQuantConfig,
-    ctx: &mut ExecutionCtx,
-) -> VortexResult<ArrayRef> {
-    // We must normalize the array before we can encode it with TurboQuant.
-    let l2_denorm = normalize_as_l2_denorm(input, ctx)?;
-    let normalized = l2_denorm.child_at(0).clone();
-    let norms = l2_denorm.child_at(1).clone();
-    let num_rows = l2_denorm.len();
-
-    let normalized_ext = normalized
-        .as_opt::<Extension>()
-        .vortex_expect("normalize_as_l2_denorm always produces an Extension array child");
-
-    // SAFETY: `normalize_as_l2_denorm` guarantees every row is unit-norm (or zero for null rows).
-    let tq = unsafe { turboquant_encode_unchecked(normalized_ext, config, ctx) }?;
-
-    // SAFETY: TurboQuant is a lossy approximation of the normalized child, so we intentionally
-    // bypass the strict normalized-row validation when reattaching the stored norms.
-    Ok(unsafe { L2Denorm::new_array_unchecked(tq, norms, num_rows) }?.into_array())
-}
-
-/// Encode a non-nullable, L2-normalized [`Vector`](crate::vector::Vector) extension array into a
-/// `ScalarFnArray(SorfTransform, [FSL(Dict(codes, centroids))])`, without validating the unit-norm
-/// precondition.
-///
-/// # Safety
-///
-/// The caller must ensure:
-///
-/// - The input dtype is non-nullable.
-/// - Every row is L2-normalized (unit norm) or is a zero vector.
-///
-/// Passing non-unit-norm vectors will not cause memory unsafety, but will produce silently
-/// incorrect quantization results.
-pub unsafe fn turboquant_encode_unchecked(
-    ext: ArrayView<Extension>,
-    config: &TurboQuantConfig,
-    ctx: &mut ExecutionCtx,
-) -> VortexResult<ArrayRef> {
-    let ext_dtype = ext.dtype().clone();
-    let storage = ext.storage_array();
-    let fsl = storage.clone().execute::<FixedSizeListArray>(ctx)?;
-
-    vortex_ensure!(
-        config.bit_width >= 1 && config.bit_width <= MAX_BIT_WIDTH,
-        "bit_width must be 1-{MAX_BIT_WIDTH}, got {}",
-        config.bit_width
-    );
-    let dimension = fsl.list_size();
-    vortex_ensure!(
-        dimension >= MIN_DIMENSION,
-        "TurboQuant requires dimension >= {MIN_DIMENSION}, got {dimension}",
-    );
-
-    let vector_metadata = ext_dtype.as_extension().metadata::<AnyVector>();
-    let element_ptype = vector_metadata.element_ptype();
-
-    let seed = config.seed;
-    let num_rows = fsl.len();
-
-    if fsl.is_empty() {
-        let padded_dim = dimension.next_power_of_two();
-        let empty_codes = PrimitiveArray::empty::<u8>(Nullability::NonNullable);
-        let empty_centroids = PrimitiveArray::empty::<f32>(Nullability::NonNullable);
-        let empty_dict =
-            DictArray::try_new(empty_codes.into_array(), empty_centroids.into_array())?;
-        let empty_fsl = FixedSizeListArray::try_new(
-            empty_dict.into_array(),
-            padded_dim,
-            Validity::NonNullable,
-            0,
-        )?;
-        let empty_padded_vector = Vector::try_new_vector_array(empty_fsl.into_array())?;
-
-        let sorf_options = SorfOptions {
-            seed,
-            num_rounds: config.num_rounds,
-            dimensions: dimension,
-            element_ptype,
-        };
-        return Ok(
-            SorfTransform::try_new_array(&sorf_options, empty_padded_vector, 0)?.into_array(),
-        );
-    }
-
-    let core = turboquant_quantize_core(&fsl, seed, config.bit_width, config.num_rounds, ctx)?;
-    let quantized_fsl =
-        build_quantized_fsl(num_rows, core.all_indices, core.centroids, core.padded_dim)?;
-    let padded_vector = Vector::try_new_vector_array(quantized_fsl)?;
-
-    let sorf_options = SorfOptions {
-        seed,
-        num_rounds: config.num_rounds,
-        dimensions: dimension,
-        element_ptype,
-    };
-    Ok(SorfTransform::try_new_array(&sorf_options, padded_vector, num_rows)?.into_array())
-}
-
-/// Shared intermediate results from the quantization loop.
-struct QuantizationResult {
-    centroids: Buffer<f32>,
-    all_indices: Buffer<u8>,
-    padded_dim: usize,
-}
-
-/// Core quantization: rotate and quantize already-normalized rows.
-///
-/// The input `fsl` must contain non-nullable, unit-norm vectors (already L2-normalized). Null
-/// vectors are not supported and must be zeroed out before reaching this function. The rotation
-/// and centroid lookup happen in f32.
-fn turboquant_quantize_core(
-    fsl: &FixedSizeListArray,
-    seed: u64,
-    bit_width: u8,
-    num_rounds: u8,
-    ctx: &mut ExecutionCtx,
-) -> VortexResult<QuantizationResult> {
-    let dimension = fsl.list_size() as usize;
-    let num_rows = fsl.len();
-
-    let padded_dim = dimension.next_power_of_two();
-    let rotation = SorfMatrix::try_new_padded(padded_dim, num_rounds as usize, seed)?;
-    let padded_dim_u32 =
-        u32::try_from(padded_dim).vortex_expect("padded_dim stays representable as u32");
-
-    let elements_prim: PrimitiveArray = fsl.elements().clone().execute(ctx)?;
-    let f32_elements = cast_to_f32(elements_prim)?;
-
-    let centroids = compute_or_get_centroids(padded_dim_u32, bit_width)?;
-    let boundaries = compute_centroid_boundaries(&centroids);
-
-    let mut all_indices = BufferMut::<u8>::with_capacity(num_rows * padded_dim);
-    let mut padded = vec![0.0f32; padded_dim];
-    let mut rotated = vec![0.0f32; padded_dim];
-
-    let f32_slice = f32_elements.as_slice();
-    for row in 0..num_rows {
-        let x = &f32_slice[row * dimension..(row + 1) * dimension];
-
-        // Zero-pad to the next power of 2.
-        padded[..dimension].copy_from_slice(x);
-        padded[dimension..].fill(0.0);
-
-        rotation.rotate(&padded, &mut rotated);
-
-        for j in 0..padded_dim {
-            all_indices.push(find_nearest_centroid(rotated[j], &boundaries));
-        }
-    }
-
-    Ok(QuantizationResult {
-        centroids,
-        all_indices: all_indices.freeze(),
-        padded_dim,
-    })
-}
-
-/// Build a quantized representation: `FSL(DictArray(codes, centroids), padded_dim)`.
-///
-/// This is a Dict-encoded FixedSizeList where each row of `padded_dim` u8 codes indexes into the
-/// centroid codebook. The Dict can be independently sliced, taken, or executed (dequantized)
-/// without knowledge of the rotation.
-fn build_quantized_fsl(
-    num_rows: usize,
-    all_indices: Buffer<u8>,
-    centroids: Buffer<f32>,
-    padded_dim: usize,
-) -> VortexResult<ArrayRef> {
-    let codes = PrimitiveArray::new::<u8>(all_indices, Validity::NonNullable);
-    let centroids_array = PrimitiveArray::new::<f32>(centroids, Validity::NonNullable);
-
-    let dict = DictArray::try_new(codes.into_array(), centroids_array.into_array())?;
-
-    let padded_dim_u32 =
-        u32::try_from(padded_dim).vortex_expect("padded_dim stays representable as u32");
-    Ok(FixedSizeListArray::try_new(
-        dict.into_array(),
-        padded_dim_u32,
-        Validity::NonNullable,
-        num_rows,
-    )?
-    .into_array())
-}
diff --git a/vortex-tensor/src/encodings/turboquant/mod.rs b/vortex-tensor/src/encodings/turboquant/mod.rs
deleted file mode 100644
index 50cef7b721e..00000000000
--- a/vortex-tensor/src/encodings/turboquant/mod.rs
+++ /dev/null
@@ -1,182 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! TurboQuant vector quantization encoding for Vortex.
-//!
-//! Implements a Stage 1 TurboQuant encoding ([arXiv:2504.19874], [RFC 0033]) for lossy
-//! compression of high-dimensional vector data. The encoding operates on [`Vector`] extension
-//! arrays, compressing their `FixedSizeList` storage into quantized codes after a structured
-//! orthogonal surrogate rotation.
-//!
-//! [arXiv:2504.19874]: https://arxiv.org/abs/2504.19874
-//! [RFC 0033]: https://vortex-data.github.io/rfcs/rfc/0033.html
-//! [`Vector`]: crate::vector::Vector
-//!
-//! # Overview
-//!
-//! TurboQuant minimizes mean-squared reconstruction error (1-8 bits per coordinate)
-//! using MSE-optimal scalar quantization on coordinates of a rotated unit vector.
-//!
-//! The encoding is decomposed into independently swappable layers:
-//!
-//! - **Normalization**: [`L2Denorm`] stores per-vector norms and wraps the compressed child.
-//! - **Orthogonal transform**: [`SorfTransform`] records the SORF structured orthogonal
-//!   transform and applies the inverse at decode time.
-//! - **Quantization**: `DictArray(codes, centroids)` wrapped in `FixedSizeListArray` stores
-//!   the per-coordinate codebook indices.
-//!
-//! The full encoded tree is:
-//!
-//! ```text
-//! ScalarFnArray(L2Denorm, [
-//!     ScalarFnArray(SorfTransform, [FSL(Dict(codes, centroids))]),
-//!     norms
-//! ])
-//! ```
-//!
-//! When executed, the tree automatically decompresses: Dict dequantizes codes → SorfTransform
-//! inverse-rotates → L2Denorm re-applies norms → original vectors (approximately).
-//!
-//! [`L2Denorm`]: crate::scalar_fns::l2_denorm::L2Denorm
-//! [`SorfTransform`]: crate::scalar_fns::sorf_transform::SorfTransform
-//!
-//! The TurboQuant paper analyzes a full random orthogonal rotation. The current Vortex
-//! implementation instead uses a fixed 3-round Walsh-Hadamard-based structured transform with
-//! random sign diagonals generated by Vortex's frozen local SplitMix64 stream. This is a practical
-//! approximation chosen for encode/decode efficiency, and should be understood as an
-//! implementation choice rather than the exact construction used in the paper's proofs.
-//!
-//! The current encoding is also intentionally MSE-only. It does not yet implement the paper's QJL
-//! residual correction for unbiased inner-product estimation, and it still uses internal
-//! power-of-2 padding rather than the block decomposition proposed in RFC 0033.
-//!
-//! # Theoretical error bounds
-//!
-//! For unit-norm vectors quantized at `b` bits per coordinate, the paper's Theorem 1
-//! guarantees normalized MSE distortion:
-//!
-//! > `E[||x - x_hat||^2 / ||x||^2] <= (sqrt(3) * pi / 2) / 4^b`
-//!
-//! | Bits | MSE bound  | Quality           |
-//! |------|------------|-------------------|
-//! | 1    | 6.80e-01   | Poor              |
-//! | 2    | 1.70e-01   | Usable for ANN    |
-//! | 3    | 4.25e-02   | Good              |
-//! | 4    | 1.06e-02   | Very good         |
-//! | 5    | 2.66e-03   | Excellent         |
-//! | 6    | 6.64e-04   | Near-lossless     |
-//! | 7    | 1.66e-04   | Near-lossless     |
-//! | 8    | 4.15e-05   | Near-lossless     |
-//!
-//! # Compression ratios
-//!
-//! Each vector is stored as `padded_dim * bit_width / 8` bytes of quantized codes plus one stored
-//! norm (in the [`L2Denorm`] wrapper). In the current implementation, that norm uses the vector's
-//! element float type, not a separate fixed storage precision. Non-power-of-2 dimensions are
-//! padded to the next power of 2 for the structured rotation, which reduces the effective ratio
-//! for those dimensions.
-//!
-//! The table below assumes f32 input, so the stored norm is 4 bytes.
-//!
-//! | dim  | padded | bits | f32 bytes | TQ bytes | ratio  |
-//! |------|--------|------|-----------|----------|--------|
-//! |  768 |   1024 |    2 |      3072 |      260 | 11.8x  |
-//! | 1024 |   1024 |    2 |      4096 |      260 | 15.8x  |
-//! |  768 |   1024 |    4 |      3072 |      516 |  6.0x  |
-//! | 1024 |   1024 |    4 |      4096 |      516 |  7.9x  |
-//! |  768 |   1024 |    8 |      3072 |     1028 |  3.0x  |
-//! | 1024 |   1024 |    8 |      4096 |     1028 |  4.0x  |
-//!
-//! # Example
-//!
-//! ```
-//! use vortex_array::IntoArray;
-//! use vortex_array::VortexSessionExecute;
-//! use vortex_array::arrays::ExtensionArray;
-//! use vortex_array::arrays::FixedSizeListArray;
-//! use vortex_array::arrays::PrimitiveArray;
-//! use vortex_array::extension::EmptyMetadata;
-//! use vortex_array::session::ArraySession;
-//! use vortex_array::validity::Validity;
-//! use vortex_buffer::BufferMut;
-//! use vortex_session::VortexSession;
-//! use vortex_tensor::encodings::turboquant::{TurboQuantConfig, turboquant_encode};
-//! use vortex_tensor::vector::Vector;
-//!
-//! // Create a Vector extension array of 100 random 128-d vectors.
-//! let num_rows = 100;
-//! let dim = 128u32;
-//! let mut buf = BufferMut::<f32>::with_capacity(num_rows * dim as usize);
-//! for i in 0..(num_rows * dim as usize) {
-//!     buf.push((i as f32 * 0.001).sin());
-//! }
-//! let elements = PrimitiveArray::new::<f32>(buf.freeze(), Validity::NonNullable);
-//! let fsl = FixedSizeListArray::try_new(
-//!     elements.into_array(), dim, Validity::NonNullable, num_rows,
-//! ).unwrap();
-//! let vector = ExtensionArray::try_new_from_vtable(Vector, EmptyMetadata, fsl.into_array())
-//!     .map(|ext| ext.into_array())
-//!     .unwrap();
-//!
-//! // Normalize and quantize at 2 bits per coordinate in one pass.
-//! let session = VortexSession::empty().with::<ArraySession>();
-//! let mut ctx = session.create_execution_ctx();
-//! let config = TurboQuantConfig { bit_width: 2, seed: 42, num_rounds: 3 };
-//! let tq = turboquant_encode(vector, &config, &mut ctx).unwrap();
-//!
-//! // Verify compression: 100 vectors x 128 dims x 4 bytes = 51200 bytes input.
-//! assert!(tq.nbytes() < 51200);
-//! ```
-
-pub(crate) mod centroids;
-pub(crate) mod compress;
-
-mod scheme;
-pub use compress::TurboQuantConfig;
-pub use compress::turboquant_encode;
-pub use compress::turboquant_encode_unchecked;
-pub use scheme::TurboQuantScheme;
-
-/// Minimum vector dimension for TurboQuant encoding.
-///
-/// Note that this is not a theoretical minimum, it is mostly a practical one to limit the total
-/// amount of distortion.
-pub const MIN_DIMENSION: u32 = 128;
-
-/// Maximum supported number of bits per quantized coordinate.
-pub const MAX_BIT_WIDTH: u8 = 8;
-
-/// Maximum supported number of centroids in the scalar quantizer codebook.
-pub const MAX_CENTROIDS: usize = 1usize << (MAX_BIT_WIDTH as usize);
-
-use vortex_array::dtype::DType;
-use vortex_error::VortexResult;
-use vortex_error::vortex_ensure;
-use vortex_error::vortex_err;
-
-use crate::types::vector::AnyVector;
-use crate::types::vector::VectorMatcherMetadata;
-
-/// Validates that `dtype` is a [`Vector`](crate::vector::Vector) extension type with
-/// dimension >= [`MIN_DIMENSION`].
-///
-/// Returns the validated vector metadata on success.
-pub fn tq_validate_vector_dtype(dtype: &DType) -> VortexResult<VectorMatcherMetadata> {
-    let vector_metadata = dtype
-        .as_extension_opt()
-        .and_then(|ext| ext.metadata_opt::<AnyVector>())
-        .ok_or_else(|| {
-            vortex_err!("TurboQuant dtype must be a Vector extension type, got {dtype}")
-        })?;
-
-    let dimensions = vector_metadata.dimensions();
-    vortex_ensure!(
-        dimensions >= MIN_DIMENSION,
-        "TurboQuant requires dimension >= {MIN_DIMENSION}, got {dimensions}",
-    );
-
-    Ok(vector_metadata)
-}
-
-#[cfg(test)]
-mod tests;
diff --git a/vortex-tensor/src/encodings/turboquant/scheme.rs b/vortex-tensor/src/encodings/turboquant/scheme.rs
deleted file mode 100644
index d4362096bd2..00000000000
--- a/vortex-tensor/src/encodings/turboquant/scheme.rs
+++ /dev/null
@@ -1,221 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! TurboQuant compression scheme.
-//!
-//! The scheme is a thin [`Scheme`] adapter over [`turboquant_encode`], which produces:
-//!
-//! ```text
-//! ScalarFnArray(L2Denorm, [
-//!     ScalarFnArray(
-//!         SorfTransform,
-//!         FSL(Dict(codes, centroids))
-//!     ),
-//!     norms
-//! ])
-//! ```
-//!
-//! Decompression is automatic: executing the outer array walks the ScalarFn tree.
-//!
-//! [`turboquant_encode`]: crate::encodings::turboquant::turboquant_encode
-
-use vortex_array::ArrayRef;
-use vortex_array::Canonical;
-use vortex_array::ExecutionCtx;
-use vortex_compressor::CascadingCompressor;
-use vortex_compressor::ctx::CompressorContext;
-use vortex_compressor::estimate::CompressionEstimate;
-use vortex_compressor::estimate::EstimateVerdict;
-use vortex_compressor::scheme::Scheme;
-use vortex_compressor::stats::ArrayAndStats;
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
-
-use crate::encodings::turboquant::MAX_CENTROIDS;
-use crate::encodings::turboquant::TurboQuantConfig;
-use crate::encodings::turboquant::tq_validate_vector_dtype;
-use crate::encodings::turboquant::turboquant_encode;
-
-/// TurboQuant compression scheme for [`Vector`] extension types.
-///
-/// Applies lossy vector quantization to [`Vector`] extension arrays using the TurboQuant algorithm
-/// with MSE-optimal encoding.
-///
-/// Register this scheme with the compressor builder via `with_scheme`:
-///
-/// ```ignore
-/// use vortex_btrblocks::BtrBlocksCompressorBuilder;
-/// use vortex_tensor::encodings::turboquant::TurboQuantScheme;
-///
-/// let compressor = BtrBlocksCompressorBuilder::default()
-///     .with_new_scheme(&TurboQuantScheme)
-///     .build();
-/// ```
-///
-/// [`Vector`]: crate::vector::Vector
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct TurboQuantScheme;
-
-impl Scheme for TurboQuantScheme {
-    fn scheme_name(&self) -> &'static str {
-        "vortex.tensor.turboquant"
-    }
-
-    fn matches(&self, canonical: &Canonical) -> bool {
-        let Canonical::Extension(ext) = canonical else {
-            return false;
-        };
-
-        tq_validate_vector_dtype(ext.dtype()).is_ok()
-    }
-
-    fn expected_compression_ratio(
-        &self,
-        data: &ArrayAndStats,
-        _compress_ctx: CompressorContext,
-        _exec_ctx: &mut ExecutionCtx,
-    ) -> CompressionEstimate {
-        let len = data.array().len();
-        let dtype = data.array().dtype();
-
-        let vector_metadata =
-            tq_validate_vector_dtype(dtype).vortex_expect("invalid dtype for TurboQuant");
-        let element_ptype = vector_metadata.element_ptype();
-        let element_bit_width: u8 = element_ptype
-            .bit_width()
-            .try_into()
-            .vortex_expect("invalid bit width for TurboQuant");
-        let dimension = vector_metadata.dimensions();
-
-        CompressionEstimate::Verdict(EstimateVerdict::Ratio(estimate_compression_ratio(
-            element_bit_width,
-            dimension,
-            len,
-        )))
-    }
-
-    fn compress(
-        &self,
-        _compressor: &CascadingCompressor,
-        data: &ArrayAndStats,
-        _compress_ctx: CompressorContext,
-        exec_ctx: &mut ExecutionCtx,
-    ) -> VortexResult<ArrayRef> {
-        turboquant_encode(data.array().clone(), &TurboQuantConfig::default(), exec_ctx)
-    }
-}
-
-// TODO(connor): If we ever add scheme vtables with metadata, we would need to pass in the config as
-// a parameter here.
-/// Estimate the compression ratio for TurboQuant MSE encoding with the default config.
-fn estimate_compression_ratio(element_bit_width: u8, dimensions: u32, num_vectors: usize) -> f64 {
-    let config = TurboQuantConfig::default();
-    let padded_dim = dimensions.next_power_of_two() as usize;
-    let element_bits = usize::from(element_bit_width);
-
-    // Get the size of the fully uncompressed vector data.
-    let uncompressed_size_bits = element_bits * dimensions as usize * num_vectors;
-
-    // Per-vector: MSE codes per padded coordinate, plus one stored norm in the input element float
-    // width.
-    let norm_bits = element_bits;
-    let compressed_bits_per_vector = usize::from(config.bit_width) * padded_dim;
-    let total_bits_per_vector = norm_bits + compressed_bits_per_vector;
-
-    // Shared overhead: codebook centroids (2^bit_width f32 values).
-    let num_centroids = 1usize << config.bit_width;
-    debug_assert!(num_centroids <= MAX_CENTROIDS);
-    let overhead_bits = num_centroids * 32; // centroids are always f32
-
-    // This includes the quantized vectors, norms, and centroid codebook.
-    let compressed_size_bits = total_bits_per_vector * num_vectors + overhead_bits;
-
-    uncompressed_size_bits as f64 / compressed_size_bits as f64
-}
-
-#[cfg(test)]
-mod tests {
-    use rstest::rstest;
-
-    use super::*;
-
-    /// Verify compression ratio for typical embedding dimensions.
-    ///
-    /// f32 input at 768-d (padded to 1024) with 1000 vectors should give ~3x.
-    /// f32 input at 1024-d (no padding) should give ~4x since no padding waste.
-    #[rstest]
-    #[case::f32_768d(32, 768, 1000, 2.5, 4.5)]
-    #[case::f32_1024d(32, 1024, 1000, 3.5, 5.0)]
-    #[case::f32_1536d(32, 1536, 1000, 2.5, 4.5)]
-    #[case::f32_128d(32, 128, 1000, 3.0, 5.0)]
-    #[case::f64_768d(64, 768, 1000, 5.0, 9.0)]
-    #[case::f16_768d(16, 768, 1000, 1.2, 2.5)]
-    fn compression_ratio_in_expected_range(
-        #[case] element_bit_width: u8,
-        #[case] dim: u32,
-        #[case] num_vectors: usize,
-        #[case] min_ratio: f64,
-        #[case] max_ratio: f64,
-    ) {
-        let ratio = estimate_compression_ratio(element_bit_width, dim, num_vectors);
-        assert!(
-            ratio > min_ratio && ratio < max_ratio,
-            "ratio {ratio:.2} not in [{min_ratio}, {max_ratio}] for \
-             {element_bit_width}-bit elements, dim={dim}, n={num_vectors}"
-        );
-    }
-
-    /// Compression ratio must always be > 1 for reasonable inputs,
-    /// otherwise TurboQuant makes things bigger and should not be selected.
-    #[rstest]
-    #[case(32, 128, 100)]
-    #[case(32, 768, 10)]
-    #[case(64, 256, 50)]
-    fn ratio_always_greater_than_one(
-        #[case] element_bit_width: u8,
-        #[case] dim: u32,
-        #[case] num_vectors: usize,
-    ) {
-        let ratio = estimate_compression_ratio(element_bit_width, dim, num_vectors);
-        assert!(
-            ratio > 1.0,
-            "ratio {ratio:.4} <= 1.0 for {element_bit_width}-bit, dim={dim}, n={num_vectors}"
-        );
-    }
-
-    #[rstest]
-    #[case(16)]
-    #[case(32)]
-    #[case(64)]
-    fn ratio_accounts_for_norm_storage_width(#[case] element_bit_width: u8) {
-        let dim = 128u32;
-        let num_vectors = 1usize;
-        let padded_dim = dim.next_power_of_two() as usize;
-        let config = TurboQuantConfig::default();
-        let num_centroids = 1usize << config.bit_width;
-
-        let expected_compressed_bits = usize::from(element_bit_width)
-            + usize::from(config.bit_width) * padded_dim
-            + num_centroids * 32;
-        let expected_uncompressed_bits =
-            usize::from(element_bit_width) * dim as usize * num_vectors;
-        let expected = expected_uncompressed_bits as f64 / expected_compressed_bits as f64;
-
-        assert_eq!(
-            estimate_compression_ratio(element_bit_width, dim, num_vectors),
-            expected
-        );
-    }
-
-    /// Power-of-2 dimensions should have better ratios than their non-power-of-2
-    /// predecessors due to no padding waste.
-    #[test]
-    fn power_of_two_has_better_ratio() {
-        let ratio_768 = estimate_compression_ratio(32, 768, 1000);
-        let ratio_1024 = estimate_compression_ratio(32, 1024, 1000);
-        assert!(
-            ratio_1024 > ratio_768,
-            "1024-d ratio ({ratio_1024:.2}) should exceed 768-d ({ratio_768:.2})"
-        );
-    }
-}
diff --git a/vortex-tensor/src/encodings/turboquant/tests/compute.rs b/vortex-tensor/src/encodings/turboquant/tests/compute.rs
deleted file mode 100644
index 4d670695eaf..00000000000
--- a/vortex-tensor/src/encodings/turboquant/tests/compute.rs
+++ /dev/null
@@ -1,216 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_array::ArrayRef;
-use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
-use vortex_array::VortexSessionExecute;
-use vortex_array::arrays::ExtensionArray;
-use vortex_array::arrays::FixedSizeListArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
-use vortex_error::VortexResult;
-
-use super::*;
-use crate::scalar_fns::cosine_similarity::CosineSimilarity;
-use crate::scalar_fns::l2_norm::L2Norm;
-
-fn execute_l2_norm(
-    input: ArrayRef,
-    len: usize,
-    ctx: &mut vortex_array::ExecutionCtx,
-) -> VortexResult<PrimitiveArray> {
-    L2Norm::try_new_array(input, len)?.into_array().execute(ctx)
-}
-
-fn execute_cosine_similarity(
-    lhs: ArrayRef,
-    rhs: ArrayRef,
-    len: usize,
-    ctx: &mut vortex_array::ExecutionCtx,
-) -> VortexResult<PrimitiveArray> {
-    CosineSimilarity::try_new_array(lhs, rhs, len)?
-        .into_array()
-        .execute(ctx)
-}
-
-#[test]
-fn slice_preserves_data() -> VortexResult<()> {
-    let fsl = make_fsl(20, 128, 42);
-    let ext = make_vector_ext(&fsl);
-    let config = TurboQuantConfig {
-        bit_width: 3,
-        seed: 123,
-        num_rounds: 4,
-    };
-    let mut ctx = SESSION.create_execution_ctx();
-    let encoded = turboquant_encode(ext, &config, &mut ctx)?;
-
-    // Full decompress then slice.
-    let mut ctx = SESSION.create_execution_ctx();
-    let full_decoded = encoded.clone().execute::<ExtensionArray>(&mut ctx)?;
-    let full_fsl = full_decoded
-        .storage_array()
-        .clone()
-        .execute::<FixedSizeListArray>(&mut ctx)?;
-    let expected = full_fsl.slice(5..10)?;
-    let expected_fsl = expected.execute::<FixedSizeListArray>(&mut ctx)?;
-    let expected_elements = expected_fsl
-        .elements()
-        .clone()
-        .execute::<PrimitiveArray>(&mut ctx)?;
-
-    // Slice then decompress.
-    let sliced = encoded.slice(5..10)?;
-    let sliced_decoded = sliced.execute::<ExtensionArray>(&mut ctx)?;
-    let sliced_fsl = sliced_decoded
-        .storage_array()
-        .clone()
-        .execute::<FixedSizeListArray>(&mut ctx)?;
-    let actual_elements = sliced_fsl
-        .elements()
-        .clone()
-        .execute::<PrimitiveArray>(&mut ctx)?;
-
-    assert_eq!(
-        expected_elements.as_slice::<f32>(),
-        actual_elements.as_slice::<f32>()
-    );
-    Ok(())
-}
-
-#[test]
-fn scalar_at_matches_decompress() -> VortexResult<()> {
-    let fsl = make_fsl(10, 128, 42);
-    let ext = make_vector_ext(&fsl);
-    let config = TurboQuantConfig {
-        bit_width: 3,
-        seed: 123,
-        num_rounds: 2,
-    };
-    let mut ctx = SESSION.create_execution_ctx();
-    let encoded = turboquant_encode(ext, &config, &mut ctx)?;
-
-    let full_decoded = encoded.clone().execute::<ExtensionArray>(&mut ctx)?;
-
-    for i in [0, 1, 5, 9] {
-        let expected =
-            full_decoded.execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())?;
-        let actual = encoded.execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())?;
-        assert_eq!(expected, actual, "scalar_at mismatch at index {i}");
-    }
-    Ok(())
-}
-
-#[test]
-fn l2_norm_readthrough() -> VortexResult<()> {
-    let fsl = make_fsl(10, 128, 42);
-    let ext = make_vector_ext(&fsl);
-    let config = TurboQuantConfig {
-        bit_width: 3,
-        seed: 123,
-        num_rounds: 5,
-    };
-    let mut ctx = SESSION.create_execution_ctx();
-    let encoded = turboquant_encode(ext, &config, &mut ctx)?;
-    let (_sorf_child, norms_child) = unwrap_l2denorm(&encoded);
-
-    // Stored norms should match the actual L2 norms of the input.
-    let norms_prim = norms_child.execute::<PrimitiveArray>(&mut ctx)?;
-    let stored_norms = norms_prim.as_slice::<f32>();
-
-    let input_prim = fsl.elements().clone().execute::<PrimitiveArray>(&mut ctx)?;
-    let input_f32 = input_prim.as_slice::<f32>();
-    for row in 0..10 {
-        let vec = &input_f32[row * 128..(row + 1) * 128];
-        let actual_norm: f32 = vec.iter().map(|&v| v * v).sum::<f32>().sqrt();
-        assert!(
-            (stored_norms[row] - actual_norm).abs() < 1e-5,
-            "norm mismatch at row {row}: stored={}, actual={}",
-            stored_norms[row],
-            actual_norm
-        );
-    }
-
-    // Also verify L2Norm readthrough shortcut works.
-    let norms = execute_l2_norm(encoded, 10, &mut ctx)?;
-    assert_eq!(norms.as_slice::<f32>(), stored_norms);
-    assert_eq!(norms.len(), 10);
-    Ok(())
-}
-
-#[test]
-fn l2_norm_readthrough_is_authoritative_for_lossy_storage() -> VortexResult<()> {
-    let num_rows = 12;
-    let fsl = make_fsl(num_rows, 128, 7);
-    let ext = make_vector_ext(&fsl);
-    let config = TurboQuantConfig {
-        bit_width: 1,
-        seed: 123,
-        num_rounds: 3,
-    };
-    let mut ctx = SESSION.create_execution_ctx();
-    let encoded = turboquant_encode(ext, &config, &mut ctx)?;
-    let (_sorf_child, norms_child) = unwrap_l2denorm(&encoded);
-
-    let stored_norms: PrimitiveArray = norms_child.execute(&mut ctx)?;
-    let encoded_norms = execute_l2_norm(encoded.clone(), num_rows, &mut ctx)?;
-    assert_eq!(
-        encoded_norms.as_slice::<f32>(),
-        stored_norms.as_slice::<f32>()
-    );
-
-    let decoded = encoded.execute::<ExtensionArray>(&mut ctx)?.into_array();
-    let decoded_norms = execute_l2_norm(decoded, num_rows, &mut ctx)?;
-    let max_gap = stored_norms
-        .as_slice::<f32>()
-        .iter()
-        .zip(decoded_norms.as_slice::<f32>().iter())
-        .map(|(&stored, &decoded)| (stored - decoded).abs())
-        .fold(0.0f32, f32::max);
-
-    assert!(
-        max_gap > 1e-3,
-        "expected at least one decoded norm to drift from the authoritative stored norms, got max gap {max_gap:.6}",
-    );
-    Ok(())
-}
-
-#[test]
-fn cosine_similarity_readthrough_is_authoritative_for_lossy_storage() -> VortexResult<()> {
-    let num_rows = 12;
-    let fsl = make_fsl(num_rows, 128, 11);
-    let ext = make_vector_ext(&fsl);
-    let config = TurboQuantConfig {
-        bit_width: 1,
-        seed: 123,
-        num_rounds: 3,
-    };
-    let mut ctx = SESSION.create_execution_ctx();
-    let encoded = turboquant_encode(ext, &config, &mut ctx)?;
-
-    let encoded_cos =
-        execute_cosine_similarity(encoded.clone(), encoded.clone(), num_rows, &mut ctx)?;
-    let decoded = encoded.execute::<ExtensionArray>(&mut ctx)?.into_array();
-    let decoded_cos = execute_cosine_similarity(decoded.clone(), decoded, num_rows, &mut ctx)?;
-
-    let decoded_values = decoded_cos.as_slice::<f32>();
-    assert!(
-        decoded_values
-            .iter()
-            .all(|&value| (value - 1.0).abs() < 1e-5),
-        "decoded cosine(x, x) should stay at 1.0",
-    );
-
-    let max_gap = encoded_cos
-        .as_slice::<f32>()
-        .iter()
-        .zip(decoded_values.iter())
-        .map(|(&encoded, &decoded)| (encoded - decoded).abs())
-        .fold(0.0f32, f32::max);
-    assert!(
-        max_gap > 1e-3,
-        "expected encoded cosine readthrough to differ from decoded recomputation, got max gap {max_gap:.6}",
-    );
-    Ok(())
-}
diff --git a/vortex-tensor/src/encodings/turboquant/tests/mod.rs b/vortex-tensor/src/encodings/turboquant/tests/mod.rs
deleted file mode 100644
index a9667f6d665..00000000000
--- a/vortex-tensor/src/encodings/turboquant/tests/mod.rs
+++ /dev/null
@@ -1,163 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Tests for TurboQuant encoding with decomposed SorfTransform + DictArray tree.
-
-mod compute;
-mod nullable;
-mod roundtrip;
-mod structural;
-
-use std::f32;
-
-use rand::SeedableRng;
-use rand::rngs::StdRng;
-use rand_distr::Distribution;
-use rand_distr::Normal;
-use vortex_array::ArrayRef;
-use vortex_array::IntoArray;
-use vortex_array::VortexSessionExecute;
-use vortex_array::arrays::Dict;
-use vortex_array::arrays::ExtensionArray;
-use vortex_array::arrays::FixedSizeListArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::ScalarFn;
-use vortex_array::arrays::dict::DictArraySlotsExt;
-use vortex_array::arrays::extension::ExtensionArrayExt;
-use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
-use vortex_array::arrays::scalar_fn::ScalarFnArrayExt;
-use vortex_array::validity::Validity;
-use vortex_buffer::BufferMut;
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
-
-use crate::encodings::turboquant::TurboQuantConfig;
-use crate::encodings::turboquant::turboquant_encode;
-use crate::tests::SESSION;
-use crate::types::vector::Vector;
-
-/// Create a FixedSizeListArray of random f32 vectors with the given validity.
-fn make_fsl_with_validity(
-    num_rows: usize,
-    dim: usize,
-    seed: u64,
-    validity: Validity,
-) -> FixedSizeListArray {
-    let mut rng = StdRng::seed_from_u64(seed);
-    let normal = Normal::new(0.0f32, 1.0).unwrap();
-
-    let mut buf = BufferMut::<f32>::with_capacity(num_rows * dim);
-    for _ in 0..(num_rows * dim) {
-        buf.push(normal.sample(&mut rng));
-    }
-
-    let elements = PrimitiveArray::new::<f32>(buf.freeze(), Validity::NonNullable);
-    FixedSizeListArray::try_new(
-        elements.into_array(),
-        dim.try_into()
-            .expect("somehow got dimension greater than u32::MAX"),
-        validity,
-        num_rows,
-    )
-    .unwrap()
-}
-
-/// Create a non-nullable FixedSizeListArray of random f32 vectors.
-fn make_fsl(num_rows: usize, dim: usize, seed: u64) -> FixedSizeListArray {
-    make_fsl_with_validity(num_rows, dim, seed, Validity::NonNullable)
-}
-
-/// Wrap a `FixedSizeListArray` in a `Vector` extension array.
-fn make_vector_ext(fsl: &FixedSizeListArray) -> ArrayRef {
-    Vector::try_new_vector_array(fsl.clone().into_array())
-        .vortex_expect("test FSL satisfies Vector storage constraints")
-}
-
-/// Unwrap an L2Denorm ScalarFnArray into (sorf_child, norms_child).
-fn unwrap_l2denorm(encoded: &ArrayRef) -> (ArrayRef, ArrayRef) {
-    let sfn = encoded
-        .as_opt::<ScalarFn>()
-        .expect("expected ScalarFnArray (L2Denorm)");
-    (sfn.child_at(0).clone(), sfn.child_at(1).clone())
-}
-
-/// Navigate the full tree to get (codes, centroids, norms) as flat arrays.
-fn unwrap_codes_centroids_norms(
-    encoded: &ArrayRef,
-    ctx: &mut vortex_array::ExecutionCtx,
-) -> VortexResult<(PrimitiveArray, PrimitiveArray, PrimitiveArray)> {
-    let (sorf_child, norms_child) = unwrap_l2denorm(encoded);
-    let padded_vector_child = sorf_child
-        .as_opt::<ScalarFn>()
-        .expect("expected SorfTransform ScalarFnArray")
-        .child_at(0)
-        .clone();
-
-    // Vector<padded_dim> wrapping FSL(Dict(codes, centroids))
-    let padded_vector: ExtensionArray = padded_vector_child.execute(ctx)?;
-    let fsl: FixedSizeListArray = padded_vector.storage_array().clone().execute(ctx)?;
-    let dict = fsl
-        .elements()
-        .as_opt::<Dict>()
-        .vortex_expect("FSL elements should be a DictArray");
-    let codes: PrimitiveArray = dict.codes().clone().execute(ctx)?;
-    let centroids: PrimitiveArray = dict.values().clone().execute(ctx)?;
-    let norms: PrimitiveArray = norms_child.execute(ctx)?;
-
-    Ok((codes, centroids, norms))
-}
-
-fn theoretical_mse_bound(bit_width: u8) -> f32 {
-    let sqrt3_pi_over_2 = (3.0f32).sqrt() * f32::consts::PI / 2.0;
-    sqrt3_pi_over_2 / (4.0f32).powi(bit_width as i32)
-}
-
-fn per_vector_normalized_mse(
-    original: &[f32],
-    reconstructed: &[f32],
-    dim: usize,
-    num_rows: usize,
-) -> f32 {
-    let mut total = 0.0f32;
-    for row in 0..num_rows {
-        let orig = &original[row * dim..(row + 1) * dim];
-        let recon = &reconstructed[row * dim..(row + 1) * dim];
-        let norm_sq: f32 = orig.iter().map(|&v| v * v).sum();
-        if norm_sq < 1e-10 {
-            continue;
-        }
-        let err_sq: f32 = orig
-            .iter()
-            .zip(recon.iter())
-            .map(|(&a, &b)| (a - b) * (a - b))
-            .sum();
-        total += err_sq / norm_sq;
-    }
-    total / num_rows as f32
-}
-
-/// Normalize, encode, and decode, returning (original, decoded) flat f32 slices.
-fn encode_decode(
-    fsl: &FixedSizeListArray,
-    config: &TurboQuantConfig,
-) -> VortexResult<(Vec<f32>, Vec<f32>)> {
-    let mut ctx = SESSION.create_execution_ctx();
-    let original: Vec<f32> = {
-        let prim = fsl.elements().clone().execute::<PrimitiveArray>(&mut ctx)?;
-        prim.as_slice::<f32>().to_vec()
-    };
-    let encoded = turboquant_encode(make_vector_ext(fsl), config, &mut ctx)?;
-    let decoded_ext = encoded.execute::<ExtensionArray>(&mut ctx)?;
-    let decoded_fsl = decoded_ext
-        .storage_array()
-        .clone()
-        .execute::<FixedSizeListArray>(&mut ctx)?;
-    let decoded_elements: Vec<f32> = {
-        let prim = decoded_fsl
-            .elements()
-            .clone()
-            .execute::<PrimitiveArray>(&mut ctx)?;
-        prim.as_slice::<f32>().to_vec()
-    };
-    Ok((original, decoded_elements))
-}
diff --git a/vortex-tensor/src/encodings/turboquant/tests/nullable.rs b/vortex-tensor/src/encodings/turboquant/tests/nullable.rs
deleted file mode 100644
index e3febbaab7b..00000000000
--- a/vortex-tensor/src/encodings/turboquant/tests/nullable.rs
+++ /dev/null
@@ -1,178 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_array::VortexSessionExecute;
-use vortex_array::arrays::ExtensionArray;
-use vortex_array::arrays::FixedSizeListArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::extension::ExtensionArrayExt;
-use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
-use vortex_array::validity::Validity;
-use vortex_error::VortexResult;
-
-use super::*;
-
-/// Encode a nullable Vector array and verify roundtrip preserves validity and non-null values.
-#[test]
-fn nullable_vectors_roundtrip() -> VortexResult<()> {
-    let validity = Validity::from_iter([
-        true, true, false, true, true, false, true, false, true, true,
-    ]);
-    let fsl = make_fsl_with_validity(10, 128, 42, validity);
-    let ext = make_vector_ext(&fsl);
-
-    let config = TurboQuantConfig {
-        bit_width: 3,
-        seed: 123,
-        num_rounds: 4,
-    };
-    let mut ctx = SESSION.create_execution_ctx();
-    let encoded = turboquant_encode(ext, &config, &mut ctx)?;
-
-    assert_eq!(encoded.len(), 10);
-    assert!(encoded.dtype().is_nullable());
-
-    let encoded_validity = encoded.validity()?;
-    for i in 0..10 {
-        let expected = ![2, 5, 7].contains(&i);
-        assert_eq!(
-            encoded_validity.is_valid(i)?,
-            expected,
-            "validity mismatch at row {i}"
-        );
-    }
-
-    let decoded_ext = encoded.execute::<ExtensionArray>(&mut ctx)?;
-    assert_eq!(decoded_ext.len(), 10);
-
-    let decoded_fsl = decoded_ext
-        .storage_array()
-        .clone()
-        .execute::<FixedSizeListArray>(&mut ctx)?;
-    let decoded_prim = decoded_fsl
-        .elements()
-        .clone()
-        .execute::<PrimitiveArray>(&mut ctx)?;
-    let decoded_f32 = decoded_prim.as_slice::<f32>();
-
-    let orig_prim = fsl.elements().clone().execute::<PrimitiveArray>(&mut ctx)?;
-    let orig_f32 = orig_prim.as_slice::<f32>();
-
-    for row in [0, 1, 3, 4, 6, 8, 9] {
-        let orig_vec = &orig_f32[row * 128..(row + 1) * 128];
-        let dec_vec = &decoded_f32[row * 128..(row + 1) * 128];
-        let norm_sq: f32 = orig_vec.iter().map(|&v| v * v).sum();
-        let err_sq: f32 = orig_vec
-            .iter()
-            .zip(dec_vec.iter())
-            .map(|(&a, &b)| (a - b) * (a - b))
-            .sum();
-        assert!(
-            err_sq / norm_sq < 0.1,
-            "non-null row {row} has excessive reconstruction error"
-        );
-    }
-    Ok(())
-}
-
-/// Verify that norms carry the validity: null vectors have null norms.
-#[test]
-fn nullable_norms_match_validity() -> VortexResult<()> {
-    let validity = Validity::from_iter([true, false, true, false, true]);
-    let fsl = make_fsl_with_validity(5, 128, 42, validity);
-    let ext = make_vector_ext(&fsl);
-
-    let config = TurboQuantConfig {
-        bit_width: 2,
-        seed: 123,
-        num_rounds: 3,
-    };
-    let mut ctx = SESSION.create_execution_ctx();
-    let encoded = turboquant_encode(ext, &config, &mut ctx)?;
-    let (_sorf_child, norms_child) = unwrap_l2denorm(&encoded);
-
-    let norms_validity = norms_child.validity()?;
-    for i in 0..5 {
-        let expected = i % 2 == 0;
-        assert_eq!(
-            norms_validity.is_valid(i)?,
-            expected,
-            "norms validity mismatch at row {i}"
-        );
-    }
-    Ok(())
-}
-
-/// Verify that L2Norm readthrough works correctly on nullable TurboQuant arrays.
-#[test]
-fn nullable_l2_norm_readthrough() -> VortexResult<()> {
-    use crate::scalar_fns::l2_norm::L2Norm;
-
-    let validity = Validity::from_iter([true, false, true, false, true]);
-    let fsl = make_fsl_with_validity(5, 128, 42, validity);
-    let ext = make_vector_ext(&fsl);
-
-    let config = TurboQuantConfig {
-        bit_width: 3,
-        seed: 123,
-        num_rounds: 3,
-    };
-    let mut ctx = SESSION.create_execution_ctx();
-    let encoded = turboquant_encode(ext, &config, &mut ctx)?;
-
-    let norm_sfn = L2Norm::try_new_array(encoded, 5)?;
-    let norms: PrimitiveArray = norm_sfn.into_array().execute(&mut ctx)?;
-
-    let orig_prim = fsl.elements().clone().execute::<PrimitiveArray>(&mut ctx)?;
-    let orig_f32 = orig_prim.as_slice::<f32>();
-    for row in 0..5 {
-        if row % 2 == 0 {
-            assert!(norms.is_valid(row, &mut ctx)?, "row {row} should be valid");
-            let expected: f32 = orig_f32[row * 128..(row + 1) * 128]
-                .iter()
-                .map(|&v| v * v)
-                .sum::<f32>()
-                .sqrt();
-            let actual = norms.as_slice::<f32>()[row];
-            assert!(
-                (actual - expected).abs() < 1e-5,
-                "norm mismatch at valid row {row}: actual={actual}, expected={expected}"
-            );
-        } else {
-            assert!(!norms.is_valid(row, &mut ctx)?, "row {row} should be null");
-        }
-    }
-    Ok(())
-}
-
-/// Verify that slicing a nullable TurboQuant array preserves validity.
-#[test]
-fn nullable_slice_preserves_validity() -> VortexResult<()> {
-    let validity = Validity::from_iter([
-        true, true, false, true, true, false, true, false, true, true,
-    ]);
-    let fsl = make_fsl_with_validity(10, 128, 42, validity);
-    let ext = make_vector_ext(&fsl);
-
-    let config = TurboQuantConfig {
-        bit_width: 3,
-        seed: 123,
-        num_rounds: 2,
-    };
-    let mut ctx = SESSION.create_execution_ctx();
-    let encoded = turboquant_encode(ext, &config, &mut ctx)?;
-
-    let sliced = encoded.slice(1..6)?;
-    assert_eq!(sliced.len(), 5);
-
-    let sliced_validity = sliced.validity()?;
-    let expected = [true, false, true, true, false];
-    for (i, &exp) in expected.iter().enumerate() {
-        assert_eq!(
-            sliced_validity.is_valid(i)?,
-            exp,
-            "sliced validity mismatch at index {i}"
-        );
-    }
-    Ok(())
-}
diff --git a/vortex-tensor/src/encodings/turboquant/tests/roundtrip.rs b/vortex-tensor/src/encodings/turboquant/tests/roundtrip.rs
deleted file mode 100644
index d82be3cf714..00000000000
--- a/vortex-tensor/src/encodings/turboquant/tests/roundtrip.rs
+++ /dev/null
@@ -1,313 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use rstest::rstest;
-use vortex_array::IntoArray;
-use vortex_array::VortexSessionExecute;
-use vortex_array::arrays::Extension;
-use vortex_array::arrays::ExtensionArray;
-use vortex_array::arrays::FixedSizeListArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::validity::Validity;
-use vortex_buffer::BufferMut;
-use vortex_error::VortexResult;
-use vortex_error::vortex_err;
-
-use super::*;
-use crate::encodings::turboquant::turboquant_encode_unchecked;
-use crate::scalar_fns::l2_denorm::normalize_as_l2_denorm;
-
-#[rstest]
-#[case(128, 1)]
-#[case(128, 2)]
-#[case(128, 3)]
-#[case(128, 4)]
-#[case(128, 6)]
-#[case(128, 8)]
-#[case(256, 2)]
-fn roundtrip(#[case] dim: usize, #[case] bit_width: u8) -> VortexResult<()> {
-    let fsl = make_fsl(10, dim, 42);
-    let config = TurboQuantConfig {
-        bit_width,
-        seed: 123,
-        num_rounds: 3,
-    };
-    let (original, decoded) = encode_decode(&fsl, &config)?;
-    assert_eq!(decoded.len(), original.len());
-    Ok(())
-}
-
-#[rstest]
-#[case(128, 1)]
-#[case(128, 2)]
-#[case(128, 3)]
-#[case(128, 4)]
-#[case(256, 2)]
-#[case(256, 4)]
-fn mse_within_theoretical_bound(#[case] dim: usize, #[case] bit_width: u8) -> VortexResult<()> {
-    let num_rows = 200;
-    let fsl = make_fsl(num_rows, dim, 42);
-    let config = TurboQuantConfig {
-        bit_width,
-        seed: 123,
-        num_rounds: 3,
-    };
-    let (original, decoded) = encode_decode(&fsl, &config)?;
-
-    let normalized_mse = per_vector_normalized_mse(&original, &decoded, dim, num_rows);
-    let bound = theoretical_mse_bound(bit_width);
-
-    assert!(
-        normalized_mse < bound,
-        "Normalized MSE {normalized_mse:.6} exceeds bound {bound:.6} \
-             for dim={dim}, bits={bit_width}",
-    );
-    Ok(())
-}
-
-#[rstest]
-#[case(128, 6)]
-#[case(128, 8)]
-#[case(256, 6)]
-#[case(256, 8)]
-fn high_bitwidth_mse_is_small(#[case] dim: usize, #[case] bit_width: u8) -> VortexResult<()> {
-    let num_rows = 200;
-    let fsl = make_fsl(num_rows, dim, 42);
-
-    let config_4bit = TurboQuantConfig {
-        bit_width: 4,
-        seed: 123,
-        num_rounds: 3,
-    };
-    let (original_4, decoded_4) = encode_decode(&fsl, &config_4bit)?;
-    let mse_4bit = per_vector_normalized_mse(&original_4, &decoded_4, dim, num_rows);
-
-    let config = TurboQuantConfig {
-        bit_width,
-        seed: 123,
-        num_rounds: 3,
-    };
-    let (original, decoded) = encode_decode(&fsl, &config)?;
-    let mse = per_vector_normalized_mse(&original, &decoded, dim, num_rows);
-
-    assert!(
-        mse < mse_4bit,
-        "{bit_width}-bit MSE ({mse:.6}) should be < 4-bit MSE ({mse_4bit:.6})"
-    );
-    assert!(mse < 0.01, "{bit_width}-bit MSE ({mse:.6}) should be < 1%");
-    Ok(())
-}
-
-#[test]
-fn mse_decreases_with_bits() -> VortexResult<()> {
-    let dim = 128;
-    let num_rows = 50;
-    let fsl = make_fsl(num_rows, dim, 99);
-
-    let mut prev_mse = f32::MAX;
-    for bit_width in 1..=8u8 {
-        let config = TurboQuantConfig {
-            bit_width,
-            seed: 123,
-            num_rounds: 3,
-        };
-        let (original, decoded) = encode_decode(&fsl, &config)?;
-        let mse = per_vector_normalized_mse(&original, &decoded, dim, num_rows);
-        assert!(
-            mse <= prev_mse * 1.01,
-            "MSE should decrease: {bit_width}-bit={mse:.6} > prev={prev_mse:.6}"
-        );
-        prev_mse = mse;
-    }
-    Ok(())
-}
-
-#[rstest]
-#[case(0)]
-#[case(1)]
-fn roundtrip_edge_cases(#[case] num_rows: usize) -> VortexResult<()> {
-    let fsl = make_fsl(num_rows, 128, 42);
-    let ext = make_vector_ext(&fsl);
-    let config = TurboQuantConfig {
-        bit_width: 2,
-        seed: 123,
-        num_rounds: 3,
-    };
-    let mut ctx = SESSION.create_execution_ctx();
-    let encoded = turboquant_encode(ext, &config, &mut ctx)?;
-    let decoded = encoded.execute::<ExtensionArray>(&mut ctx)?;
-    assert_eq!(decoded.len(), num_rows);
-    Ok(())
-}
-
-#[rstest]
-#[case(1)]
-#[case(64)]
-#[case(127)]
-fn rejects_dimension_below_128(#[case] dim: usize) {
-    let elements = PrimitiveArray::new::<f32>(
-        BufferMut::from_iter((0..dim).map(|i| i as f32 + 1.0)).freeze(),
-        Validity::NonNullable,
-    );
-    let fsl = FixedSizeListArray::try_new(
-        elements.into_array(),
-        dim.try_into().expect("dim fits u32"),
-        Validity::NonNullable,
-        1,
-    )
-    .unwrap();
-    let ext = make_vector_ext(&fsl);
-    let config = TurboQuantConfig {
-        bit_width: 2,
-        seed: 0,
-        num_rounds: 3,
-    };
-    let mut ctx = SESSION.create_execution_ctx();
-    assert!(turboquant_encode(ext, &config, &mut ctx).is_err());
-}
-
-#[rstest]
-#[case(0)]
-#[case(9)]
-fn rejects_invalid_bit_width(#[case] bit_width: u8) {
-    let fsl = make_fsl(10, 128, 42);
-    let ext = make_vector_ext(&fsl);
-    let config = TurboQuantConfig {
-        bit_width,
-        seed: 0,
-        num_rounds: 3,
-    };
-    let mut ctx = SESSION.create_execution_ctx();
-    let normalized = normalize_as_l2_denorm(ext, &mut ctx)
-        .unwrap()
-        .child_at(0)
-        .clone();
-    let normalized_ext = normalized
-        .as_opt::<Extension>()
-        .expect("normalized child should be Extension");
-    assert!(unsafe { turboquant_encode_unchecked(normalized_ext, &config, &mut ctx) }.is_err());
-}
-
-#[test]
-fn all_zero_vectors_roundtrip() -> VortexResult<()> {
-    let num_rows = 10;
-    let dim = 128;
-    let buf = BufferMut::<f32>::full(0.0f32, num_rows * dim);
-    let elements = PrimitiveArray::new::<f32>(buf.freeze(), Validity::NonNullable);
-    let fsl = FixedSizeListArray::try_new(
-        elements.into_array(),
-        dim.try_into().map_err(|e| vortex_err!("{e}"))?,
-        Validity::NonNullable,
-        num_rows,
-    )?;
-
-    let config = TurboQuantConfig {
-        bit_width: 3,
-        seed: 42,
-        num_rounds: 3,
-    };
-    let (original, decoded) = encode_decode(&fsl, &config)?;
-    for (i, (&o, &d)) in original.iter().zip(decoded.iter()).enumerate() {
-        assert_eq!(o, 0.0, "original[{i}] not zero");
-        assert_eq!(d, 0.0, "decoded[{i}] not zero for all-zero input");
-    }
-    Ok(())
-}
-
-/// Roundtrip at large embedding dimensions.
-#[rstest]
-#[case(768, 4)]
-#[case(1024, 5)]
-fn large_dimension_roundtrip(#[case] dim: usize, #[case] bit_width: u8) -> VortexResult<()> {
-    let num_rows = 10;
-    let fsl = make_fsl(num_rows, dim, 42);
-    let config = TurboQuantConfig {
-        bit_width,
-        seed: 123,
-        num_rounds: 3,
-    };
-    let (original, decoded) = encode_decode(&fsl, &config)?;
-    assert_eq!(decoded.len(), original.len());
-
-    let normalized_mse = per_vector_normalized_mse(&original, &decoded, dim, num_rows);
-    // 2x slack for the SRHT-vs-Haar gap.
-    let bound = 2.0 * theoretical_mse_bound(bit_width);
-    assert!(
-        normalized_mse < bound,
-        "Normalized MSE {normalized_mse:.6} exceeds 2x bound {bound:.6} for dim={dim}, bits={bit_width}",
-    );
-    Ok(())
-}
-
-/// Verify that f64 input is accepted and encoded.
-#[test]
-fn f64_input_encodes_successfully() -> VortexResult<()> {
-    let num_rows = 10;
-    let dim = 128;
-    let mut rng = StdRng::seed_from_u64(99);
-    let normal = Normal::new(0.0f64, 1.0).map_err(|e| vortex_err!("{e}"))?;
-
-    let mut buf = BufferMut::<f64>::with_capacity(num_rows * dim);
-    for _ in 0..(num_rows * dim) {
-        buf.push(normal.sample(&mut rng));
-    }
-    let elements = PrimitiveArray::new::<f64>(buf.freeze(), Validity::NonNullable);
-    let fsl = FixedSizeListArray::try_new(
-        elements.into_array(),
-        dim.try_into().map_err(|e| vortex_err!("{e}"))?,
-        Validity::NonNullable,
-        num_rows,
-    )?;
-
-    let ext = make_vector_ext(&fsl);
-    let config = TurboQuantConfig {
-        bit_width: 3,
-        seed: 42,
-        num_rounds: 3,
-    };
-    let mut ctx = SESSION.create_execution_ctx();
-    let encoded = turboquant_encode(ext, &config, &mut ctx)?;
-    let (_sorf_child, norms_child) = unwrap_l2denorm(&encoded);
-    assert_eq!(norms_child.len(), num_rows);
-    Ok(())
-}
-
-/// Verify that f16 input is accepted and encoded.
-#[test]
-fn f16_input_encodes_successfully() -> VortexResult<()> {
-    let num_rows = 10;
-    let dim = 128;
-    let mut rng = StdRng::seed_from_u64(99);
-    let normal = Normal::new(0.0f32, 1.0).map_err(|e| vortex_err!("{e}"))?;
-
-    let mut buf = BufferMut::<half::f16>::with_capacity(num_rows * dim);
-    for _ in 0..(num_rows * dim) {
-        buf.push(half::f16::from_f32(normal.sample(&mut rng)));
-    }
-    let elements = PrimitiveArray::new::<half::f16>(buf.freeze(), Validity::NonNullable);
-    let fsl = FixedSizeListArray::try_new(
-        elements.into_array(),
-        dim.try_into().map_err(|e| vortex_err!("{e}"))?,
-        Validity::NonNullable,
-        num_rows,
-    )?;
-
-    let ext = make_vector_ext(&fsl);
-    let config = TurboQuantConfig {
-        bit_width: 3,
-        seed: 42,
-        num_rounds: 3,
-    };
-    let mut ctx = SESSION.create_execution_ctx();
-    let encoded = turboquant_encode(ext, &config, &mut ctx)?;
-    let (_sorf_child, norms_child) = unwrap_l2denorm(&encoded);
-    assert_eq!(norms_child.len(), num_rows);
-
-    let decoded_ext = encoded.execute::<ExtensionArray>(&mut ctx)?;
-    let decoded_fsl = decoded_ext
-        .storage_array()
-        .clone()
-        .execute::<FixedSizeListArray>(&mut ctx)?;
-    assert_eq!(decoded_fsl.len(), num_rows);
-    Ok(())
-}
diff --git a/vortex-tensor/src/encodings/turboquant/tests/structural.rs b/vortex-tensor/src/encodings/turboquant/tests/structural.rs
deleted file mode 100644
index 3b49f1da7c4..00000000000
--- a/vortex-tensor/src/encodings/turboquant/tests/structural.rs
+++ /dev/null
@@ -1,334 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Tests that verify the internal structure of the encoded tree.
-
-use vortex_array::VortexSessionExecute;
-use vortex_array::arrays::ExtensionArray;
-use vortex_array::arrays::FixedSizeListArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::extension::ExtensionArrayExt;
-use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
-use vortex_error::VortexResult;
-
-use super::*;
-use crate::encodings::turboquant::centroids::compute_or_get_centroids;
-
-/// Verify that the centroids stored in the DictArray match what `compute_or_get_centroids()` computes.
-#[test]
-fn stored_centroids_match_computed() -> VortexResult<()> {
-    let fsl = make_fsl(10, 128, 42);
-    let ext = make_vector_ext(&fsl);
-    let config = TurboQuantConfig {
-        bit_width: 3,
-        seed: 123,
-        num_rounds: 3,
-    };
-    let mut ctx = SESSION.create_execution_ctx();
-    let encoded = turboquant_encode(ext, &config, &mut ctx)?;
-
-    let (_codes, centroids, _norms) = unwrap_codes_centroids_norms(&encoded, &mut ctx)?;
-    let stored = centroids.as_slice::<f32>();
-
-    // padded_dim for dim=128 is 128.
-    let computed = compute_or_get_centroids(128, 3)?;
-
-    assert_eq!(stored.len(), computed.len());
-    for i in 0..stored.len() {
-        assert_eq!(stored[i], computed[i], "Centroid mismatch at {i}");
-    }
-    Ok(())
-}
-
-/// Verify that the rotation is deterministic from seed by checking decode output.
-#[test]
-fn seed_deterministic_rotation_produces_correct_decode() -> VortexResult<()> {
-    let fsl = make_fsl(20, 128, 42);
-    let ext = make_vector_ext(&fsl);
-    let config = TurboQuantConfig {
-        bit_width: 3,
-        seed: 123,
-        num_rounds: 4,
-    };
-
-    // Encode twice with the same seed → should produce identical results.
-    let mut ctx = SESSION.create_execution_ctx();
-    let encoded1 = turboquant_encode(ext.clone(), &config, &mut ctx)?;
-    let decoded1 = encoded1.execute::<ExtensionArray>(&mut ctx)?;
-    let fsl1 = decoded1
-        .storage_array()
-        .clone()
-        .execute::<FixedSizeListArray>(&mut ctx)?;
-    let elems1 = fsl1
-        .elements()
-        .clone()
-        .execute::<PrimitiveArray>(&mut ctx)?;
-
-    let mut ctx = SESSION.create_execution_ctx();
-    let encoded2 = turboquant_encode(ext, &config, &mut ctx)?;
-    let decoded2 = encoded2.execute::<ExtensionArray>(&mut ctx)?;
-    let fsl2 = decoded2
-        .storage_array()
-        .clone()
-        .execute::<FixedSizeListArray>(&mut ctx)?;
-    let elems2 = fsl2
-        .elements()
-        .clone()
-        .execute::<PrimitiveArray>(&mut ctx)?;
-
-    assert_eq!(
-        elems1.as_slice::<f32>(),
-        elems2.as_slice::<f32>(),
-        "Two encodes with same seed should produce identical decode output"
-    );
-    Ok(())
-}
-
-/// Verify that the encoded array's dtype is a Vector extension type.
-#[test]
-fn encoded_dtype_is_vector_extension() -> VortexResult<()> {
-    let fsl = make_fsl(10, 128, 42);
-    let ext = make_vector_ext(&fsl);
-    let config = TurboQuantConfig {
-        bit_width: 3,
-        seed: 123,
-        num_rounds: 2,
-    };
-    let mut ctx = SESSION.create_execution_ctx();
-    let encoded = turboquant_encode(ext, &config, &mut ctx)?;
-
-    assert!(
-        encoded.dtype().is_extension(),
-        "TurboQuant dtype should be an extension type, got {}",
-        encoded.dtype()
-    );
-    assert!(
-        encoded.dtype().as_extension().is::<Vector>(),
-        "TurboQuant dtype should be a Vector extension type"
-    );
-    Ok(())
-}
-
-/// Verify approximate cosine similarity in the quantized domain.
-#[test]
-fn cosine_similarity_quantized_accuracy() -> VortexResult<()> {
-    let fsl = make_fsl(20, 128, 42);
-    let ext = make_vector_ext(&fsl);
-    let config = TurboQuantConfig {
-        bit_width: 4,
-        seed: 123,
-        num_rounds: 3,
-    };
-    let mut ctx = SESSION.create_execution_ctx();
-    let encoded = turboquant_encode(ext, &config, &mut ctx)?;
-
-    let input_prim = fsl.elements().clone().execute::<PrimitiveArray>(&mut ctx)?;
-    let input_f32 = input_prim.as_slice::<f32>();
-
-    // Navigate tree to get codes, centroids, norms.
-    let (codes_prim, centroids_prim, norms_prim) =
-        unwrap_codes_centroids_norms(&encoded, &mut ctx)?;
-    let all_codes = codes_prim.as_slice::<u8>();
-    let centroid_vals = centroids_prim.as_slice::<f32>();
-    let norms = norms_prim.as_slice::<f32>();
-
-    // padded_dim for dim=128.
-    let pd = 128usize;
-
-    for (row_a, row_b) in [(0, 1), (5, 10), (0, 19)] {
-        let vec_a = &input_f32[row_a * 128..(row_a + 1) * 128];
-        let vec_b = &input_f32[row_b * 128..(row_b + 1) * 128];
-
-        let dot: f32 = vec_a.iter().zip(vec_b.iter()).map(|(&x, &y)| x * y).sum();
-        let norm_a: f32 = vec_a.iter().map(|&v| v * v).sum::<f32>().sqrt();
-        let norm_b: f32 = vec_b.iter().map(|&v| v * v).sum::<f32>().sqrt();
-        let exact_cos = dot / (norm_a * norm_b);
-
-        let approx_cos = if norms[row_a] == 0.0 || norms[row_b] == 0.0 {
-            0.0
-        } else {
-            let codes_a = &all_codes[row_a * pd..(row_a + 1) * pd];
-            let codes_b = &all_codes[row_b * pd..(row_b + 1) * pd];
-            codes_a
-                .iter()
-                .zip(codes_b.iter())
-                .map(|(&ca, &cb)| centroid_vals[ca as usize] * centroid_vals[cb as usize])
-                .sum::<f32>()
-        };
-
-        let error = (exact_cos - approx_cos).abs();
-        assert!(
-            error < 0.15,
-            "cosine similarity error too large for ({row_a}, {row_b}): \
-                 exact={exact_cos:.4}, approx={approx_cos:.4}, error={error:.4}"
-        );
-    }
-    Ok(())
-}
-
-/// Verify approximate dot product in the quantized domain.
-#[test]
-fn dot_product_quantized_accuracy() -> VortexResult<()> {
-    let fsl = make_fsl(20, 128, 42);
-    let ext = make_vector_ext(&fsl);
-    let config = TurboQuantConfig {
-        bit_width: 8,
-        seed: 123,
-        num_rounds: 3,
-    };
-    let mut ctx = SESSION.create_execution_ctx();
-    let encoded = turboquant_encode(ext, &config, &mut ctx)?;
-
-    let input_prim = fsl.elements().clone().execute::<PrimitiveArray>(&mut ctx)?;
-    let input_f32 = input_prim.as_slice::<f32>();
-
-    let (codes_prim, centroids_prim, norms_prim) =
-        unwrap_codes_centroids_norms(&encoded, &mut ctx)?;
-    let all_codes = codes_prim.as_slice::<u8>();
-    let centroid_vals = centroids_prim.as_slice::<f32>();
-    let norms = norms_prim.as_slice::<f32>();
-
-    let pd = 128usize;
-
-    for (row_a, row_b) in [(0, 1), (5, 10), (0, 19)] {
-        let vec_a = &input_f32[row_a * 128..(row_a + 1) * 128];
-        let vec_b = &input_f32[row_b * 128..(row_b + 1) * 128];
-
-        let exact_dot: f32 = vec_a.iter().zip(vec_b.iter()).map(|(&x, &y)| x * y).sum();
-
-        let codes_a = &all_codes[row_a * pd..(row_a + 1) * pd];
-        let codes_b = &all_codes[row_b * pd..(row_b + 1) * pd];
-        let unit_dot: f32 = codes_a
-            .iter()
-            .zip(codes_b.iter())
-            .map(|(&ca, &cb)| centroid_vals[ca as usize] * centroid_vals[cb as usize])
-            .sum();
-        let approx_dot = norms[row_a] * norms[row_b] * unit_dot;
-
-        let scale = exact_dot.abs().max(1.0);
-        let rel_error = (exact_dot - approx_dot).abs() / scale;
-        assert!(
-            rel_error < 0.15,
-            "dot product error too large for ({row_a}, {row_b}): \
-                 exact={exact_dot:.4}, approx={approx_dot:.4}, rel_error={rel_error:.4}"
-        );
-    }
-    Ok(())
-}
-
-/// Verify SorfTransform in isolation: manually forward-rotate known data, wrap in
-/// FSL(Dict), execute SorfTransform, and check inverse rotation recovers the original.
-#[test]
-#[expect(
-    clippy::cast_possible_truncation,
-    reason = "test uses known small dimensions"
-)]
-fn sorf_transform_roundtrip_isolation() -> VortexResult<()> {
-    use vortex_array::IntoArray;
-    use vortex_array::arrays::dict::DictArray;
-    use vortex_array::dtype::extension::ExtDType;
-    use vortex_array::extension::EmptyMetadata;
-    use vortex_array::validity::Validity;
-    use vortex_buffer::BufferMut;
-
-    use crate::encodings::turboquant::centroids::compute_centroid_boundaries;
-    use crate::encodings::turboquant::centroids::compute_or_get_centroids;
-    use crate::encodings::turboquant::centroids::find_nearest_centroid;
-    use crate::scalar_fns::sorf_transform::SorfMatrix;
-    use crate::scalar_fns::sorf_transform::SorfOptions;
-    use crate::scalar_fns::sorf_transform::SorfTransform;
-    use crate::types::vector::Vector;
-
-    let dim = 128usize;
-    let seed = 99u64;
-    let num_rounds = 3u8;
-    let num_rows = 5;
-
-    // Build a known input: simple increasing values, then normalize each row to unit norm.
-    let mut input_f32 = vec![0.0f32; num_rows * dim];
-    for row in 0..num_rows {
-        let mut norm_sq = 0.0f32;
-        for i in 0..dim {
-            let val = ((row * dim + i) as f32 + 1.0) * 0.01;
-            input_f32[row * dim + i] = val;
-            norm_sq += val * val;
-        }
-        let norm = norm_sq.sqrt();
-        for i in 0..dim {
-            input_f32[row * dim + i] /= norm;
-        }
-    }
-
-    // Forward transform + quantize (mimicking what turboquant_quantize_core does).
-    let padded_dim = dim.next_power_of_two();
-    let rotation = SorfMatrix::try_new_padded(padded_dim, num_rounds as usize, seed)?;
-    let centroids = compute_or_get_centroids(padded_dim as u32, 8)?;
-    let boundaries = compute_centroid_boundaries(&centroids);
-
-    let mut all_indices = BufferMut::<u8>::with_capacity(num_rows * padded_dim);
-    let mut padded = vec![0.0f32; padded_dim];
-    let mut rotated = vec![0.0f32; padded_dim];
-
-    for row in 0..num_rows {
-        padded[..dim].copy_from_slice(&input_f32[row * dim..(row + 1) * dim]);
-        padded[dim..].fill(0.0);
-        rotation.rotate(&padded, &mut rotated);
-        for j in 0..padded_dim {
-            all_indices.push(find_nearest_centroid(rotated[j], &boundaries));
-        }
-    }
-
-    // Build FSL(Dict(codes, centroids)).
-    let codes = PrimitiveArray::new::<u8>(all_indices.freeze(), Validity::NonNullable);
-    let mut centroids_buf = BufferMut::<f32>::with_capacity(centroids.len());
-    centroids_buf.extend_from_slice(&centroids);
-    let centroids_arr = PrimitiveArray::new::<f32>(centroids_buf.freeze(), Validity::NonNullable);
-    let dict = DictArray::try_new(codes.into_array(), centroids_arr.into_array())?;
-    let fsl = FixedSizeListArray::try_new(
-        dict.into_array(),
-        padded_dim as u32,
-        Validity::NonNullable,
-        num_rows,
-    )?;
-
-    // Wrap the padded FSL in a Vector extension so it can be the SorfTransform child.
-    let padded_vector_dtype =
-        ExtDType::<Vector>::try_new(EmptyMetadata, fsl.dtype().clone())?.erased();
-    let padded_vector = ExtensionArray::new(padded_vector_dtype, fsl.into_array());
-
-    // Wrap in SorfTransform and execute.
-    let sorf_options = SorfOptions {
-        seed,
-        num_rounds,
-        dimensions: dim as u32,
-        element_ptype: vortex_array::dtype::PType::F32,
-    };
-    let sorf_array =
-        SorfTransform::try_new_array(&sorf_options, padded_vector.into_array(), num_rows)?;
-
-    let mut ctx = SESSION.create_execution_ctx();
-    let result: ExtensionArray = sorf_array.into_array().execute(&mut ctx)?;
-    let result_fsl: FixedSizeListArray = result.storage_array().clone().execute(&mut ctx)?;
-    let result_prim: PrimitiveArray = result_fsl.elements().clone().execute(&mut ctx)?;
-    let result_f32 = result_prim.as_slice::<f32>();
-
-    assert_eq!(result_f32.len(), num_rows * dim);
-
-    // At 8-bit quantization, reconstruction should be very close to input.
-    for row in 0..num_rows {
-        let orig = &input_f32[row * dim..(row + 1) * dim];
-        let recon = &result_f32[row * dim..(row + 1) * dim];
-        let err_sq: f32 = orig
-            .iter()
-            .zip(recon)
-            .map(|(&a, &b)| (a - b) * (a - b))
-            .sum();
-        let norm_sq: f32 = orig.iter().map(|&v| v * v).sum();
-        assert!(
-            err_sq / norm_sq < 1e-3,
-            "SorfTransform isolation: row {row} MSE too high: {:.6}",
-            err_sq / norm_sq
-        );
-    }
-    Ok(())
-}
diff --git a/vortex-tensor/src/lib.rs b/vortex-tensor/src/lib.rs
index 92d5422c200..0a0b3a8a2ee 100644
--- a/vortex-tensor/src/lib.rs
+++ b/vortex-tensor/src/lib.rs
@@ -23,7 +23,6 @@ use crate::scalar_fns::cosine_similarity::CosineSimilarity;
 use crate::scalar_fns::inner_product::InnerProduct;
 use crate::scalar_fns::l2_denorm::L2Denorm;
 use crate::scalar_fns::l2_norm::L2Norm;
-use crate::scalar_fns::sorf_transform::SorfTransform;
 use crate::types::fixed_shape_tensor::FixedShapeTensor;
 use crate::types::vector::Vector;
 
@@ -42,8 +41,8 @@ pub mod vector_search;
 mod utils;
 
 /// Environment variable that gates registration of the tensor scalar-fn array plugins (the array
-/// encodings that let [`CosineSimilarity`], [`InnerProduct`], [`L2Denorm`], [`L2Norm`], and
-/// [`SorfTransform`] persist in a Vortex file). When unset, only the scalar functions themselves
+/// encodings that let [`CosineSimilarity`], [`InnerProduct`], [`L2Denorm`], and [`L2Norm`]
+/// persist in a Vortex file). When unset, only the scalar functions themselves
 /// are registered; readers of files containing serialized tensor scalar-fn arrays will fail to
 /// deserialize. Opt-in by setting the variable to any non-empty value.
 pub const SCALAR_FN_ARRAY_TENSOR_PLUGIN_ENV: &str = "VX_SCALAR_FN_ARRAY_TENSOR_PLUGIN";
@@ -63,7 +62,6 @@ pub fn initialize(session: &VortexSession) {
     session_fns.register(InnerProduct);
     session_fns.register(L2Denorm);
     session_fns.register(L2Norm);
-    session_fns.register(SorfTransform);
 
     // Registering the scalar-fn array plugins lets the tensor scalar fns be serialized as array
     // encodings inside Vortex files. Gate this on an env var so applications that do not intend
@@ -76,7 +74,6 @@ pub fn initialize(session: &VortexSession) {
         session_arrays.register(ScalarFnArrayPlugin::new(InnerProduct));
         session_arrays.register(ScalarFnArrayPlugin::new(L2Denorm));
         session_arrays.register(ScalarFnArrayPlugin::new(L2Norm));
-        session_arrays.register(ScalarFnArrayPlugin::new(SorfTransform));
     }
 }
 
diff --git a/vortex-tensor/src/scalar_fns/cosine_similarity.rs b/vortex-tensor/src/scalar_fns/cosine_similarity.rs
index 7dc24a878a4..82328a9b2d9 100644
--- a/vortex-tensor/src/scalar_fns/cosine_similarity.rs
+++ b/vortex-tensor/src/scalar_fns/cosine_similarity.rs
@@ -28,6 +28,7 @@ use vortex_array::serde::ArrayChildren;
 use vortex_buffer::Buffer;
 use vortex_error::VortexResult;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 
 use crate::scalar_fns::inner_product::InnerProduct;
 use crate::scalar_fns::l2_denorm::DenormOrientation;
@@ -47,7 +48,7 @@ use crate::utils::validate_binary_tensor_float_inputs;
 /// same dtype and a float element type. The output is a float column of the same float type.
 ///
 /// When either input is wrapped in [`L2Denorm`], this operator treats the stored norms and
-/// normalized children as authoritative. For lossy encodings such as TurboQuant, that means the
+/// normalized children as authoritative. For lossy encodings, that means the
 /// optimized readthrough path may intentionally differ slightly from decoding both sides to dense
 /// coordinates and recomputing cosine from scratch.
 ///
@@ -70,8 +71,8 @@ impl CosineSimilarity {
     ///
     /// Returns an error if the [`ScalarFnArray`] cannot be constructed (e.g. due to dtype
     /// mismatches).
-    pub fn try_new_array(lhs: ArrayRef, rhs: ArrayRef, len: usize) -> VortexResult<ScalarFnArray> {
-        ScalarFnArray::try_new(CosineSimilarity::new().erased(), vec![lhs, rhs], len)
+    pub fn try_new_array(lhs: ArrayRef, rhs: ArrayRef) -> VortexResult<ScalarFnArray> {
+        ScalarFnArray::try_new(CosineSimilarity::new().erased(), vec![lhs, rhs])
     }
 }
 
@@ -79,7 +80,8 @@ impl ScalarFnVTable for CosineSimilarity {
     type Options = EmptyOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.tensor.cosine_similarity")
+        static ID: CachedId = CachedId::new("vortex.tensor.cosine_similarity");
+        *ID
     }
 
     fn arity(&self, _options: &Self::Options) -> Arity {
@@ -139,9 +141,9 @@ impl ScalarFnVTable for CosineSimilarity {
         let validity = lhs_ref.validity()?.and(rhs_ref.validity()?)?;
 
         // Compute inner product and norms as columnar operations, and propagate the options.
-        let norm_lhs_arr = L2Norm::try_new_array(lhs_ref.clone(), len)?;
-        let norm_rhs_arr = L2Norm::try_new_array(rhs_ref.clone(), len)?;
-        let dot_arr = InnerProduct::try_new_array(lhs_ref, rhs_ref, len)?;
+        let norm_lhs_arr = L2Norm::try_new_array(lhs_ref.clone())?;
+        let norm_rhs_arr = L2Norm::try_new_array(rhs_ref.clone())?;
+        let dot_arr = InnerProduct::try_new_array(lhs_ref, rhs_ref)?;
 
         // Execute to get the inner product and norms of the arrays. We only fully decompress
         // because we need to perform special logic (guard against 0) during division.
@@ -237,7 +239,7 @@ impl CosineSimilarity {
         // `L2Denorm` makes the normalized children authoritative, so their dot product is the
         // cosine similarity even for lossy storage wrappers, except that a zero stored norm still
         // represents a zero vector.
-        let dot: PrimitiveArray = InnerProduct::try_new_array(normalized_l, normalized_r, len)?
+        let dot: PrimitiveArray = InnerProduct::try_new_array(normalized_l, normalized_r)?
             .into_array()
             .execute(ctx)?;
         let norms_l: PrimitiveArray = norms_l.execute(ctx)?;
@@ -277,12 +279,12 @@ impl CosineSimilarity {
 
         let (normalized, denorm_norms) = extract_l2_denorm_children(denorm_ref);
 
-        let dot_arr = InnerProduct::try_new_array(normalized, plain_ref.clone(), len)?;
+        let dot_arr = InnerProduct::try_new_array(normalized, plain_ref.clone())?;
         let dot: PrimitiveArray = dot_arr.into_array().execute(ctx)?;
 
         let denorm_norms: PrimitiveArray = denorm_norms.execute(ctx)?;
 
-        let norm_arr = L2Norm::try_new_array(plain_ref.clone(), len)?;
+        let norm_arr = L2Norm::try_new_array(plain_ref.clone())?;
         let plain_norm: PrimitiveArray = norm_arr.into_array().execute(ctx)?;
 
         // TODO(connor): Ideally we would have a `SafeDiv` binary numeric operation.
@@ -333,9 +335,9 @@ mod tests {
     use crate::utils::test_helpers::vector_array;
 
     /// Evaluates cosine similarity between two tensor arrays and returns the result as `Vec<f64>`.
-    fn eval_cosine_similarity(lhs: ArrayRef, rhs: ArrayRef, len: usize) -> VortexResult<Vec<f64>> {
+    fn eval_cosine_similarity(lhs: ArrayRef, rhs: ArrayRef) -> VortexResult<Vec<f64>> {
         let scalar_fn = CosineSimilarity::new().erased();
-        let result = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs], len)?;
+        let result = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])?;
         let mut ctx = SESSION.create_execution_ctx();
         let prim: PrimitiveArray = result.into_array().execute(&mut ctx)?;
         Ok(prim.as_slice::<f64>().to_vec())
@@ -359,7 +361,7 @@ mod tests {
         )?;
 
         // Row 0: identical -> 1.0, row 1: orthogonal -> 0.0.
-        assert_close(&eval_cosine_similarity(lhs, rhs, 2)?, &[1.0, 0.0]);
+        assert_close(&eval_cosine_similarity(lhs, rhs)?, &[1.0, 0.0]);
         Ok(())
     }
 
@@ -379,7 +381,7 @@ mod tests {
     ) -> VortexResult<()> {
         let lhs = tensor_array(shape, lhs_elems)?;
         let rhs = tensor_array(shape, rhs_elems)?;
-        assert_close(&eval_cosine_similarity(lhs, rhs, 1)?, expected);
+        assert_close(&eval_cosine_similarity(lhs, rhs)?, expected);
         Ok(())
     }
 
@@ -398,7 +400,7 @@ mod tests {
     fn self_similarity(#[case] shape: &[usize], #[case] elements: &[f64]) -> VortexResult<()> {
         let lhs = tensor_array(shape, elements)?;
         let rhs = tensor_array(shape, elements)?;
-        assert_close(&eval_cosine_similarity(lhs, rhs, 1)?, &[1.0]);
+        assert_close(&eval_cosine_similarity(lhs, rhs)?, &[1.0]);
         Ok(())
     }
 
@@ -409,7 +411,7 @@ mod tests {
         let rhs = tensor_array(&[], &[5.0, -3.0])?;
 
         // Same sign -> 1.0, opposite sign -> -1.0.
-        assert_close(&eval_cosine_similarity(lhs, rhs, 2)?, &[1.0, -1.0]);
+        assert_close(&eval_cosine_similarity(lhs, rhs)?, &[1.0, -1.0]);
         Ok(())
     }
 
@@ -429,7 +431,7 @@ mod tests {
         let rhs = lhs.clone();
 
         assert_close(
-            &eval_cosine_similarity(lhs, rhs, 5)?,
+            &eval_cosine_similarity(lhs, rhs)?,
             &[1.0, 1.0, 1.0, 1.0, 1.0],
         );
         Ok(())
@@ -449,10 +451,7 @@ mod tests {
         )?;
         let query = constant_tensor_array(&[3], &[1.0, 0.0, 0.0], 4)?;
 
-        assert_close(
-            &eval_cosine_similarity(data, query, 4)?,
-            &[1.0, 0.0, 0.0, 1.0],
-        );
+        assert_close(&eval_cosine_similarity(data, query)?, &[1.0, 0.0, 0.0, 1.0]);
         Ok(())
     }
 
@@ -474,7 +473,7 @@ mod tests {
         )?;
 
         // Row 0: identical -> 1.0, row 1: orthogonal -> 0.0.
-        assert_close(&eval_cosine_similarity(lhs, rhs, 2)?, &[1.0, 0.0]);
+        assert_close(&eval_cosine_similarity(lhs, rhs)?, &[1.0, 0.0]);
         Ok(())
     }
 
@@ -491,10 +490,7 @@ mod tests {
         )?;
         let query = Vector::constant_array(&[1.0, 0.0, 0.0], 4)?;
 
-        assert_close(
-            &eval_cosine_similarity(data, query, 4)?,
-            &[1.0, 0.0, 0.0, 1.0],
-        );
+        assert_close(&eval_cosine_similarity(data, query)?, &[1.0, 0.0, 0.0, 1.0]);
         Ok(())
     }
 
@@ -506,7 +502,7 @@ mod tests {
         let rhs = MaskedArray::try_new(rhs, Validity::from_iter([true, false]))?.into_array();
 
         let scalar_fn = CosineSimilarity::new().erased();
-        let result = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs], 2)?;
+        let result = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])?;
         let mut ctx = SESSION.create_execution_ctx();
         let prim: PrimitiveArray = result.into_array().execute(&mut ctx)?;
 
@@ -526,7 +522,7 @@ mod tests {
         let rhs = l2_denorm_array(&[2], &[0.6, 0.8, 1.0, 0.0], &[5.0, 1.0], &mut ctx)?;
 
         // Self-similarity should always be 1.0.
-        assert_close(&eval_cosine_similarity(lhs, rhs, 2)?, &[1.0, 1.0]);
+        assert_close(&eval_cosine_similarity(lhs, rhs)?, &[1.0, 1.0]);
         Ok(())
     }
 
@@ -538,7 +534,7 @@ mod tests {
         let lhs = l2_denorm_array(&[2], &[1.0, 0.0], &[3.0], &mut ctx)?;
         let rhs = l2_denorm_array(&[2], &[0.0, 1.0], &[4.0], &mut ctx)?;
 
-        assert_close(&eval_cosine_similarity(lhs, rhs, 1)?, &[0.0]);
+        assert_close(&eval_cosine_similarity(lhs, rhs)?, &[0.0]);
         Ok(())
     }
 
@@ -550,7 +546,7 @@ mod tests {
         let rhs = l2_denorm_array(&[2], &[0.6, 0.8, 1.0, 0.0], &[5.0, 1.0], &mut ctx)?;
 
         // Row 0: dot([0.6, 0.8], [0.6, 0.8]) = 1.0, row 1: dot([0,0], [1,0]) = 0.0.
-        assert_close(&eval_cosine_similarity(lhs, rhs, 2)?, &[1.0, 0.0]);
+        assert_close(&eval_cosine_similarity(lhs, rhs)?, &[1.0, 0.0]);
         Ok(())
     }
 
@@ -563,7 +559,7 @@ mod tests {
         let lhs = l2_denorm_array(&[2], &[0.6, 0.8], &[5.0], &mut ctx)?;
         let rhs = tensor_array(&[2], &[3.0, 4.0])?;
 
-        assert_close(&eval_cosine_similarity(lhs, rhs, 1)?, &[1.0]);
+        assert_close(&eval_cosine_similarity(lhs, rhs)?, &[1.0]);
         Ok(())
     }
 
@@ -575,7 +571,7 @@ mod tests {
         let lhs = tensor_array(&[2], &[1.0, 0.0])?;
         let rhs = l2_denorm_array(&[2], &[0.6, 0.8], &[5.0], &mut ctx)?;
 
-        assert_close(&eval_cosine_similarity(lhs, rhs, 1)?, &[0.6]);
+        assert_close(&eval_cosine_similarity(lhs, rhs)?, &[0.6]);
         Ok(())
     }
 
@@ -587,10 +583,10 @@ mod tests {
 
         let normalized_r = tensor_array(&[2], &[0.6, 0.8, 1.0, 0.0])?;
         let norms_r = PrimitiveArray::from_option_iter([Some(5.0f64), None]).into_array();
-        let rhs = L2Denorm::try_new_array(normalized_r, norms_r, 2, &mut ctx)?.into_array();
+        let rhs = L2Denorm::try_new_array(normalized_r, norms_r, &mut ctx)?.into_array();
 
         let scalar_fn = CosineSimilarity::new().erased();
-        let result = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs], 2)?;
+        let result = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])?;
         let prim: PrimitiveArray = result.into_array().execute(&mut ctx)?;
 
         assert!(prim.is_valid(0, &mut ctx)?);
@@ -601,7 +597,7 @@ mod tests {
 
     #[test]
     fn both_denorm_lossy_zero_stored_norm_returns_zero() -> VortexResult<()> {
-        // Mimics a lossy encoding (e.g. TurboQuant) where the stored norm is authoritative but
+        // Mimics a lossy encoding where the stored norm is authoritative but
         // the decoded normalized child is physically nonzero. With a stored norm of `0.0`, cosine
         // similarity for that row must be `0.0` even though the dot product of the normalized
         // children is nonzero.
@@ -609,22 +605,22 @@ mod tests {
         let norms_l = PrimitiveArray::from_iter([0.0f64]).into_array();
         // SAFETY: This is a focused test that intentionally violates the unit-norm invariant by
         // pairing a nonzero normalized row with a stored norm of `0.0`, mimicking lossy storage.
-        let lhs = unsafe { L2Denorm::new_array_unchecked(normalized_l, norms_l, 1)? }.into_array();
+        let lhs = unsafe { L2Denorm::new_array_unchecked(normalized_l, norms_l)? }.into_array();
 
         let normalized_r = tensor_array(&[2], &[0.6, 0.8])?;
         let norms_r = PrimitiveArray::from_iter([0.0f64]).into_array();
         // SAFETY: Same as above for the rhs operand.
-        let rhs = unsafe { L2Denorm::new_array_unchecked(normalized_r, norms_r, 1)? }.into_array();
+        let rhs = unsafe { L2Denorm::new_array_unchecked(normalized_r, norms_r)? }.into_array();
 
         // `dot(normalized_l, normalized_r) = 1.0`, but the authoritative stored norms are both
         // `0.0`, so cosine similarity must be `0.0`.
-        assert_close(&eval_cosine_similarity(lhs, rhs, 1)?, &[0.0]);
+        assert_close(&eval_cosine_similarity(lhs, rhs)?, &[0.0]);
         Ok(())
     }
 
     #[test]
     fn one_side_denorm_lossy_zero_stored_norm_returns_zero() -> VortexResult<()> {
-        // Mimics a lossy encoding (e.g. TurboQuant) where the stored norm is authoritative but
+        // Mimics a lossy encoding where the stored norm is authoritative but
         // the decoded normalized child is physically nonzero. The plain side is a normal nonzero
         // tensor with positive norm. cosine similarity must still be `0.0` because the
         // authoritative stored norm on the denorm side is `0.0`.
@@ -632,19 +628,19 @@ mod tests {
         let norms = PrimitiveArray::from_iter([0.0f64]).into_array();
         // SAFETY: This is a focused test that intentionally pairs a nonzero normalized row with a
         // stored norm of `0.0`, mimicking lossy storage where the stored norm is authoritative.
-        let denorm = unsafe { L2Denorm::new_array_unchecked(normalized, norms, 1)? }.into_array();
+        let denorm = unsafe { L2Denorm::new_array_unchecked(normalized, norms)? }.into_array();
 
         let plain = tensor_array(&[2], &[1.0, 0.0])?;
 
         // Denorm on the lhs: `One { denorm: lhs, plain: rhs }`.
         assert_close(
-            &eval_cosine_similarity(denorm.clone(), plain.clone(), 1)?,
+            &eval_cosine_similarity(denorm.clone(), plain.clone())?,
             &[0.0],
         );
 
         // Denorm on the rhs: `One { denorm: rhs, plain: lhs }`. The same zero-norm guard must
         // fire regardless of operand order.
-        assert_close(&eval_cosine_similarity(plain, denorm, 1)?, &[0.0]);
+        assert_close(&eval_cosine_similarity(plain, denorm)?, &[0.0]);
         Ok(())
     }
 
@@ -663,7 +659,7 @@ mod tests {
             ],
         )?;
         assert_close(
-            &eval_cosine_similarity(lhs, rhs, 4)?,
+            &eval_cosine_similarity(lhs, rhs)?,
             &[1.0 / 3.0, 1.0, 2.0 / 3.0, 8.0 / 9.0],
         );
         Ok(())
@@ -683,7 +679,7 @@ mod tests {
         )?;
         let rhs = constant_tensor_array(&[3], &[1.0, 2.0, 2.0], 4)?;
         assert_close(
-            &eval_cosine_similarity(lhs, rhs, 4)?,
+            &eval_cosine_similarity(lhs, rhs)?,
             &[1.0 / 3.0, 1.0, 2.0 / 3.0, 8.0 / 9.0],
         );
         Ok(())
@@ -696,7 +692,7 @@ mod tests {
         let rhs = constant_tensor_array(&[3], &[1.0, 1.0, 0.0], 3)?;
         let expected = 1.0 / 2.0_f64.sqrt();
         assert_close(
-            &eval_cosine_similarity(lhs, rhs, 3)?,
+            &eval_cosine_similarity(lhs, rhs)?,
             &[expected, expected, expected],
         );
         Ok(())
@@ -715,7 +711,7 @@ mod tests {
                 7.0, 8.0, 9.0, //
             ],
         )?;
-        assert_close(&eval_cosine_similarity(lhs, rhs, 3)?, &[0.0, 0.0, 0.0]);
+        assert_close(&eval_cosine_similarity(lhs, rhs)?, &[0.0, 0.0, 0.0]);
         Ok(())
     }
 
@@ -726,7 +722,7 @@ mod tests {
         // L2Denorm fast path's inner product yields 1.
         let lhs = constant_tensor_array(&[3], &[3.0, 4.0, 0.0], 5)?;
         let rhs = constant_tensor_array(&[3], &[3.0, 4.0, 0.0], 5)?;
-        assert_close(&eval_cosine_similarity(lhs, rhs, 5)?, &[1.0; 5]);
+        assert_close(&eval_cosine_similarity(lhs, rhs)?, &[1.0; 5]);
         Ok(())
     }
 
@@ -744,21 +740,17 @@ mod tests {
             ],
         )?;
         assert_close(
-            &eval_cosine_similarity(lhs, rhs, 4)?,
+            &eval_cosine_similarity(lhs, rhs)?,
             &[1.0 / 3.0, 1.0, 2.0 / 3.0, 8.0 / 9.0],
         );
         Ok(())
     }
 
     #[rstest]
-    #[case::vector(cosine_vector_lhs(), cosine_vector_rhs(), 2)]
-    #[case::fixed_shape_tensor(cosine_tensor_lhs(), cosine_tensor_rhs(), 2)]
-    fn serde_round_trip(
-        #[case] lhs: ArrayRef,
-        #[case] rhs: ArrayRef,
-        #[case] len: usize,
-    ) -> VortexResult<()> {
-        let original = CosineSimilarity::try_new_array(lhs.clone(), rhs.clone(), len)?.into_array();
+    #[case::vector(cosine_vector_lhs(), cosine_vector_rhs())]
+    #[case::fixed_shape_tensor(cosine_tensor_lhs(), cosine_tensor_rhs())]
+    fn serde_round_trip(#[case] lhs: ArrayRef, #[case] rhs: ArrayRef) -> VortexResult<()> {
+        let original = CosineSimilarity::try_new_array(lhs.clone(), rhs.clone())?.into_array();
 
         let plugin = ScalarFnArrayPlugin::new(CosineSimilarity);
         let metadata = plugin
diff --git a/vortex-tensor/src/scalar_fns/inner_product.rs b/vortex-tensor/src/scalar_fns/inner_product.rs
index 197d5cc2fb3..cfea956f314 100644
--- a/vortex-tensor/src/scalar_fns/inner_product.rs
+++ b/vortex-tensor/src/scalar_fns/inner_product.rs
@@ -7,25 +7,16 @@ use num_traits::Float;
 use vortex_array::ArrayRef;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::arrays::Constant;
-use vortex_array::arrays::ConstantArray;
-use vortex_array::arrays::Dict;
-use vortex_array::arrays::Extension;
 use vortex_array::arrays::ExtensionArray;
-use vortex_array::arrays::FixedSizeList;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::ScalarFnArray;
-use vortex_array::arrays::dict::DictArraySlotsExt;
 use vortex_array::arrays::extension::ExtensionArrayExt;
-use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
-use vortex_array::arrays::scalar_fn::ExactScalarFn;
 use vortex_array::arrays::scalar_fn::ScalarFnArrayView;
 use vortex_array::arrays::scalar_fn::plugin::ScalarFnArrayParts;
 use vortex_array::arrays::scalar_fn::plugin::ScalarFnArrayVTable;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::NativePType;
 use vortex_array::dtype::Nullability;
-use vortex_array::dtype::PType;
 use vortex_array::expr::Expression;
 use vortex_array::expr::and;
 use vortex_array::match_each_float_ptype;
@@ -38,18 +29,14 @@ use vortex_array::scalar_fn::ScalarFnVTable;
 use vortex_array::scalar_fn::TypedScalarFnInstance;
 use vortex_array::serde::ArrayChildren;
 use vortex_buffer::Buffer;
-use vortex_buffer::BufferMut;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 
 use crate::matcher::AnyTensor;
 use crate::scalar_fns::l2_denorm::DenormOrientation;
-use crate::scalar_fns::sorf_transform::SorfMatrix;
-use crate::scalar_fns::sorf_transform::SorfTransform;
-use crate::types::vector::Vector;
 use crate::utils::BinaryTensorOpMetadata;
-use crate::utils::extract_constant_flat_row;
 use crate::utils::extract_flat_elements;
 use crate::utils::extract_l2_denorm_children;
 use crate::utils::validate_binary_tensor_float_inputs;
@@ -81,8 +68,8 @@ impl InnerProduct {
     ///
     /// Returns an error if the [`ScalarFnArray`] cannot be constructed (e.g. due to dtype
     /// mismatches).
-    pub fn try_new_array(lhs: ArrayRef, rhs: ArrayRef, len: usize) -> VortexResult<ScalarFnArray> {
-        ScalarFnArray::try_new(InnerProduct::new().erased(), vec![lhs, rhs], len)
+    pub fn try_new_array(lhs: ArrayRef, rhs: ArrayRef) -> VortexResult<ScalarFnArray> {
+        ScalarFnArray::try_new(InnerProduct::new().erased(), vec![lhs, rhs])
     }
 }
 
@@ -90,7 +77,8 @@ impl ScalarFnVTable for InnerProduct {
     type Options = EmptyOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.tensor.inner_product")
+        static ID: CachedId = CachedId::new("vortex.tensor.inner_product");
+        *ID
     }
 
     fn arity(&self, _options: &Self::Options) -> Arity {
@@ -137,20 +125,6 @@ impl ScalarFnVTable for InnerProduct {
             DenormOrientation::Neither => {}
         }
 
-        // Reduction case 1: `InnerProduct(SorfTransform(x), const)` rewrites to
-        // `InnerProduct(x, forward_rotate(zero_pad(const)))`. Re-executes recursively so
-        // case 2 can fire on the rewritten tree.
-        if let Some(rewritten) = self.try_execute_sorf_constant(&lhs_ref, &rhs_ref, len, ctx)? {
-            return Ok(rewritten);
-        }
-
-        // Reduction case 2: `InnerProduct(Vector[FSL(Dict(u8, f32))], const)` is computed by
-        // gather-summing `q[j] * values[codes[j] as usize]` per row, reading the codebook
-        // directly instead of decoding the column into dense vectors.
-        if let Some(result) = self.try_execute_dict_constant(&lhs_ref, &rhs_ref, len, ctx)? {
-            return Ok(result);
-        }
-
         // Compute combined validity.
         let validity = lhs_ref.validity()?.and(rhs_ref.validity()?)?;
 
@@ -248,7 +222,7 @@ impl InnerProduct {
         let norms_l: PrimitiveArray = norms_l.execute(ctx)?;
         let norms_r: PrimitiveArray = norms_r.execute(ctx)?;
 
-        let dot: PrimitiveArray = InnerProduct::try_new_array(normalized_l, normalized_r, len)?
+        let dot: PrimitiveArray = InnerProduct::try_new_array(normalized_l, normalized_r)?
             .into_array()
             .execute(ctx)?;
 
@@ -278,7 +252,7 @@ impl InnerProduct {
         let (normalized, norms) = extract_l2_denorm_children(denorm_ref);
         let denorm_norms: PrimitiveArray = norms.execute(ctx)?;
 
-        let dot: PrimitiveArray = InnerProduct::try_new_array(normalized, plain_ref.clone(), len)?
+        let dot: PrimitiveArray = InnerProduct::try_new_array(normalized, plain_ref.clone())?
             .into_array()
             .execute(ctx)?;
 
@@ -291,206 +265,6 @@ impl InnerProduct {
             Ok(unsafe { PrimitiveArray::new_unchecked(buffer, validity) }.into_array())
         })
     }
-
-    /// Fast path when one side is `ExactScalarFn<SorfTransform>` and the other side is a
-    /// constant-backed tensor-like extension. Rewrites to
-    /// `InnerProduct(sorf_child, forward_rotate(zero_pad(const_query)))` because SORF is
-    /// orthogonal, so `<T(R^{-1} x), c> = <x, R · zero_pad(c)>` where `T` is the truncation from
-    /// `padded_dim` to `dim` applied by `SorfTransform` and `R` is the SORF forward matrix. See the
-    /// proof in the crate-level docs and in the plan file.
-    ///
-    /// Returns `Ok(None)` if neither side matches, when the operand element type is not `F32`, or
-    /// when the constant side is not a constant-backed tensor extension. The caller is expected to
-    /// fall through to the standard path in that case.
-    ///
-    /// # F32-only
-    ///
-    /// TODO(connor): this rewrite is only sound for `PType::F32` because `SorfTransform` applies an
-    /// `f32 -> element_ptype` cast at the end of its `execute`. For `F16`/`F64` the cast changes
-    /// the inner product's rounding and the rewrite would not be semantically equivalent. Until we
-    /// push the cast through `InnerProduct`, both the SorfTransform output ptype and the
-    /// constant-side element ptype must be `F32` here.
-    fn try_execute_sorf_constant(
-        &self,
-        lhs_ref: &ArrayRef,
-        rhs_ref: &ArrayRef,
-        len: usize,
-        ctx: &mut ExecutionCtx,
-    ) -> VortexResult<Option<ArrayRef>> {
-        // Identify which side is the SorfTransform, if any.
-        let (sorf_view, const_ref) =
-            if let Some(view) = lhs_ref.as_opt::<ExactScalarFn<SorfTransform>>() {
-                (view, rhs_ref)
-            } else if let Some(view) = rhs_ref.as_opt::<ExactScalarFn<SorfTransform>>() {
-                (view, lhs_ref)
-            } else {
-                return Ok(None);
-            };
-
-        if sorf_view.options.element_ptype != PType::F32 {
-            return Ok(None);
-        }
-
-        // The other side must be a constant tensor.
-        let Some(const_storage) = constant_tensor_storage(const_ref) else {
-            return Ok(None);
-        };
-
-        let dim = sorf_view.options.dimensions as usize;
-        let num_rounds = sorf_view.options.num_rounds as usize;
-        let seed = sorf_view.options.seed;
-        let padded_dim = dim.next_power_of_two();
-
-        // Extract the single stored row of the constant.
-        let flat = extract_constant_flat_row(&const_storage, ctx)?;
-        if flat.ptype() != PType::F32 {
-            return Ok(None);
-        }
-
-        // Zero-pad the query from `dim` to `padded_dim` and forward-rotate.
-        let mut padded_query = vec![0.0f32; padded_dim];
-        padded_query[..dim].copy_from_slice(flat.as_slice::<f32>());
-
-        let rotation = SorfMatrix::try_new_padded(padded_dim, num_rounds, seed)?;
-        let mut rotated_query = vec![0.0f32; padded_dim];
-        rotation.rotate(&padded_query, &mut rotated_query);
-
-        // Wrap the rotated query as a `Vector<padded_dim, f32>` constant broadcast to `len`
-        // rows. The new extension dtype has `padded_dim` instead of `dim`, matching the
-        // SorfTransform child we are about to dot it with.
-        let new_constant = Vector::constant_array(&rotated_query, len)?;
-
-        // Extract the SorfTransform child (the already-padded Vector<padded_dim, f32>).
-        let sorf_child = sorf_view
-            .nth_child(0)
-            .vortex_expect("SorfTransform must have exactly one child");
-
-        // Recursively execute the rewritten inner product. This allows case 2 to fire on
-        // the rewritten tree if the sorf child is `Vector[FSL(Dict)]`. Termination is
-        // guaranteed because the rewrite strictly removes a `SorfTransform` scalar-fn node
-        // from the tree and SORFs cannot be nested.
-        let rewritten = InnerProduct::try_new_array(sorf_child, new_constant, len)?
-            .into_array()
-            .execute(ctx)?;
-        Ok(Some(rewritten))
-    }
-
-    /// Fast path when one side is an extension whose storage is `FSL(Dict(u8, f32))` and
-    /// the other side is a constant-backed tensor extension with an F32 element ptype.
-    ///
-    /// Computes each row's inner product as
-    ///   `out[i] = sum_{j in 0..padded_dim} q[j] * values[codes[i * padded_dim + j] as usize]`
-    /// using a direct codebook lookup in the hot loop. An explicit product table
-    /// `P[j, k] = q[j] * values[k]` (size `padded_dim * num_centroids * 4B`, ~1 MiB for the
-    /// common 1024/256 case) was tried and measured ~10% *slower* on the
-    /// `similarity_search` bench because the 1 KiB `values` table stays in L1 across all
-    /// rows, while the 1 MiB product table does not.
-    ///
-    /// Returns `Ok(None)` when the pattern doesn't match; the caller should fall through to
-    /// the standard path.
-    fn try_execute_dict_constant(
-        &self,
-        lhs_ref: &ArrayRef,
-        rhs_ref: &ArrayRef,
-        len: usize,
-        ctx: &mut ExecutionCtx,
-    ) -> VortexResult<Option<ArrayRef>> {
-        // Try each orientation. The oriented helper navigates each side exactly once, so
-        // the only redundant work here is the failed navigation of the first side when the
-        // dict happens to be on the right.
-        if let Some(result) = self.try_execute_dict_constant_oriented(lhs_ref, rhs_ref, len, ctx)? {
-            return Ok(Some(result));
-        }
-        self.try_execute_dict_constant_oriented(rhs_ref, lhs_ref, len, ctx)
-    }
-
-    /// Orientation-specific helper for [`Self::try_execute_dict_constant`]. `dict_candidate`
-    /// is tried as `Extension[FSL[Dict]]`; `const_candidate` is tried as a constant-backed
-    /// tensor extension. Returns `Ok(None)` if either navigation fails or any gate rejects.
-    fn try_execute_dict_constant_oriented(
-        &self,
-        dict_candidate: &ArrayRef,
-        const_candidate: &ArrayRef,
-        len: usize,
-        ctx: &mut ExecutionCtx,
-    ) -> VortexResult<Option<ArrayRef>> {
-        // Navigate the dict side.
-        let Some(dict_ext) = dict_candidate.as_opt::<Extension>() else {
-            return Ok(None);
-        };
-        let Some(fsl) = dict_ext.storage_array().as_opt::<FixedSizeList>() else {
-            return Ok(None);
-        };
-        let Some(dict) = fsl.elements().as_opt::<Dict>() else {
-            return Ok(None);
-        };
-
-        // Navigate the constant side and require its scalar be non-null.
-        let Some(const_storage) = constant_tensor_storage(const_candidate) else {
-            return Ok(None);
-        };
-
-        // Canonicalize codes and values. Codes may be e.g. BitPacked; executing is cheaper
-        // than falling through to the standard path (which would also canonicalize).
-        let codes_prim: PrimitiveArray = dict.codes().clone().execute(ctx)?;
-        let values_prim: PrimitiveArray = dict.values().clone().execute(ctx)?;
-
-        // Gate: u8 codes and f32 centroids.
-        if codes_prim.ptype() != PType::U8 {
-            // TODO(connor): Should we support wider codes?
-            return Ok(None);
-        }
-        if values_prim.ptype() != PType::F32 {
-            // TODO(connor): direct-lookup path only supports f32 centroids. SorfTransform
-            // forces f32 anyway, so this is the only shape we need for now.
-            return Ok(None);
-        }
-
-        let padded_dim = usize::try_from(fsl.list_size()).vortex_expect("fsl list_size fits usize");
-
-        let flat = extract_constant_flat_row(&const_storage, ctx)?;
-        if flat.ptype() != PType::F32 {
-            // TODO(connor): case 2 is f32-only. For f16/f64 we fall through to the standard
-            // path, which computes the inner product with the correct element type.
-            return Ok(None);
-        }
-
-        // Combine the input validities up front; the per-row arithmetic may write garbage
-        // into null rows but the validity mask hides it (matching the standard path).
-        let validity = dict_candidate
-            .validity()?
-            .and(const_candidate.validity()?)?;
-
-        // Fast path for the empty case: skip allocating and touching the codes buffer.
-        if len == 0 {
-            let empty = PrimitiveArray::empty::<f32>(validity.nullability());
-            return Ok(Some(empty.into_array()));
-        }
-
-        let q: &[f32] = flat.as_slice::<f32>();
-        debug_assert_eq!(q.len(), padded_dim);
-        let codes: &[u8] = codes_prim.as_slice::<u8>();
-        let values: &[f32] = values_prim.as_slice::<f32>();
-        debug_assert_eq!(codes.len(), len * padded_dim);
-
-        // The hot loop is extracted into [`execute_dict_constant_inner_product`] so the compiler
-        // can prove the chunked indices stay in bounds and vectorize the inner gather-accumulate.
-        let out = execute_dict_constant_inner_product(q, values, codes, len, padded_dim);
-
-        // SAFETY: the buffer length equals `len`, which matches the validity length.
-        let result = unsafe { PrimitiveArray::new_unchecked(out.freeze(), validity) }.into_array();
-        Ok(Some(result))
-    }
-}
-
-/// Return the storage constant for a canonical tensor-like constant query.
-fn constant_tensor_storage(array: &ArrayRef) -> Option<ArrayRef> {
-    let constant = array.as_opt::<Constant>()?;
-    if constant.scalar().is_null() {
-        return None;
-    }
-    let ext_scalar = constant.scalar().as_extension_opt()?;
-    Some(ConstantArray::new(ext_scalar.to_storage_scalar(), array.len()).into_array())
 }
 
 /// Computes the inner product (dot product) of two equal-length float slices.
@@ -503,49 +277,6 @@ fn inner_product_row<T: Float + NativePType>(a: &[T], b: &[T]) -> T {
         .fold(T::zero(), |acc, v| acc + v)
 }
 
-/// Compute inner products between a constant query vector and dictionary-encoded rows.
-///
-/// For each row, computes `sum(q[j] * values[codes[row * dim + j]])` using the codebook `values`
-/// directly instead of decoding the dictionary into dense vectors.
-///
-/// The inner loop uses `PARTIAL_SUMS` independent accumulators so the CPU can pipeline FP additions
-/// instead of waiting for each `fadd` to retire before starting the next.
-fn execute_dict_constant_inner_product(
-    q: &[f32],
-    values: &[f32],
-    codes: &[u8],
-    num_rows: usize,
-    dim: usize,
-) -> BufferMut<f32> {
-    let mut out = BufferMut::<f32>::with_capacity(num_rows);
-
-    const PARTIAL_SUMS: usize = 8;
-
-    for row_codes in codes.chunks_exact(dim) {
-        let mut acc = [0.0f32; PARTIAL_SUMS];
-
-        let code_chunks = row_codes.chunks_exact(PARTIAL_SUMS);
-        let q_chunks = q.chunks_exact(PARTIAL_SUMS);
-        let code_rem = code_chunks.remainder();
-        let q_rem = q_chunks.remainder();
-
-        for (cc, qd) in code_chunks.zip(q_chunks) {
-            for i in 0..PARTIAL_SUMS {
-                acc[i] = qd[i].mul_add(values[cc[i] as usize], acc[i]);
-            }
-        }
-
-        for (&code, &q_val) in code_rem.iter().zip(q_rem.iter()) {
-            acc[0] = q_val.mul_add(values[code as usize], acc[0]);
-        }
-
-        // SAFETY: we reserved `num_rows` slots and push exactly once per row.
-        unsafe { out.push_unchecked(acc.iter().sum::<f32>()) };
-    }
-
-    out
-}
-
 #[cfg(test)]
 mod tests {
 
@@ -570,9 +301,9 @@ mod tests {
     use crate::utils::test_helpers::vector_array;
 
     /// Evaluates inner product between two tensor arrays and returns the result as `Vec<f64>`.
-    fn eval_inner_product(lhs: ArrayRef, rhs: ArrayRef, len: usize) -> VortexResult<Vec<f64>> {
+    fn eval_inner_product(lhs: ArrayRef, rhs: ArrayRef) -> VortexResult<Vec<f64>> {
         let scalar_fn = InnerProduct::new().erased();
-        let result = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs], len)?;
+        let result = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])?;
         let mut ctx = SESSION.create_execution_ctx();
         let prim: PrimitiveArray = result.into_array().execute(&mut ctx)?;
         Ok(prim.as_slice::<f64>().to_vec())
@@ -596,7 +327,7 @@ mod tests {
     ) -> VortexResult<()> {
         let lhs = tensor_array(shape, lhs_elems)?;
         let rhs = tensor_array(shape, rhs_elems)?;
-        assert_close(&eval_inner_product(lhs, rhs, 1)?, expected);
+        assert_close(&eval_inner_product(lhs, rhs)?, expected);
         Ok(())
     }
 
@@ -618,7 +349,7 @@ mod tests {
                 2.0, 2.0, 2.0, // tensor 2: dot = 6
             ],
         )?;
-        assert_close(&eval_inner_product(lhs, rhs, 3)?, &[0.0, 25.0, 6.0]);
+        assert_close(&eval_inner_product(lhs, rhs)?, &[0.0, 25.0, 6.0]);
         Ok(())
     }
 
@@ -638,7 +369,7 @@ mod tests {
                 0.0, 1.0, // vector 1: dot = 0
             ],
         )?;
-        assert_close(&eval_inner_product(lhs, rhs, 2)?, &[25.0, 0.0]);
+        assert_close(&eval_inner_product(lhs, rhs)?, &[25.0, 0.0]);
         Ok(())
     }
 
@@ -650,7 +381,7 @@ mod tests {
         let lhs = MaskedArray::try_new(lhs, Validity::from_iter([true, false, true]))?.into_array();
 
         let scalar_fn = InnerProduct::new().erased();
-        let result = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs], 3)?;
+        let result = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])?;
         let mut ctx = SESSION.create_execution_ctx();
         let prim: PrimitiveArray = result.into_array().execute(&mut ctx)?;
 
@@ -667,7 +398,7 @@ mod tests {
     fn rejects_non_extension_dtype() {
         let lhs = PrimitiveArray::from_iter([1.0_f64, 2.0]).into_array();
         let rhs = PrimitiveArray::from_iter([3.0_f64, 4.0]).into_array();
-        let result = InnerProduct::try_new_array(lhs, rhs, 2);
+        let result = InnerProduct::try_new_array(lhs, rhs);
         assert!(result.is_err());
     }
 
@@ -675,7 +406,7 @@ mod tests {
     fn rejects_mismatched_dtypes() -> VortexResult<()> {
         let lhs = tensor_array(&[2], &[1.0_f64, 2.0])?;
         let rhs = vector_array(2, &[3.0_f64, 4.0])?;
-        let result = InnerProduct::try_new_array(lhs, rhs, 1);
+        let result = InnerProduct::try_new_array(lhs, rhs);
         assert!(result.is_err());
         Ok(())
     }
@@ -690,7 +421,7 @@ mod tests {
         let rhs = l2_denorm_array(&[2], &[1.0, 0.0], &[1.0], &mut ctx)?;
 
         // Expected: 5.0 * 1.0 * dot([0.6, 0.8], [1.0, 0.0]) = 5.0 * 0.6 = 3.0.
-        assert_close(&eval_inner_product(lhs, rhs, 1)?, &[3.0]);
+        assert_close(&eval_inner_product(lhs, rhs)?, &[3.0]);
         Ok(())
     }
 
@@ -702,7 +433,7 @@ mod tests {
         let lhs = l2_denorm_array(&[2], &[0.6, 0.8, 1.0, 0.0], &[5.0, 1.0], &mut ctx)?;
         let rhs = l2_denorm_array(&[2], &[0.6, 0.8, 0.0, 1.0], &[5.0, 1.0], &mut ctx)?;
 
-        assert_close(&eval_inner_product(lhs, rhs, 2)?, &[25.0, 0.0]);
+        assert_close(&eval_inner_product(lhs, rhs)?, &[25.0, 0.0]);
         Ok(())
     }
 
@@ -715,7 +446,7 @@ mod tests {
         let lhs = l2_denorm_array(&[2], &[0.6, 0.8], &[5.0], &mut ctx)?;
         let rhs = tensor_array(&[2], &[1.0, 2.0])?;
 
-        assert_close(&eval_inner_product(lhs, rhs, 1)?, &[11.0]);
+        assert_close(&eval_inner_product(lhs, rhs)?, &[11.0]);
         Ok(())
     }
 
@@ -728,7 +459,7 @@ mod tests {
         let lhs = tensor_array(&[2], &[1.0, 2.0])?;
         let rhs = l2_denorm_array(&[2], &[0.6, 0.8], &[5.0], &mut ctx)?;
 
-        assert_close(&eval_inner_product(lhs, rhs, 1)?, &[11.0]);
+        assert_close(&eval_inner_product(lhs, rhs)?, &[11.0]);
         Ok(())
     }
 
@@ -739,11 +470,11 @@ mod tests {
         let norms_l = PrimitiveArray::from_option_iter([Some(5.0f64), None]).into_array();
         let mut ctx = SESSION.create_execution_ctx();
 
-        let lhs = L2Denorm::try_new_array(normalized_l, norms_l, 2, &mut ctx)?.into_array();
+        let lhs = L2Denorm::try_new_array(normalized_l, norms_l, &mut ctx)?.into_array();
         let rhs = l2_denorm_array(&[2], &[0.6, 0.8, 1.0, 0.0], &[5.0, 1.0], &mut ctx)?;
 
         let scalar_fn = InnerProduct::new().erased();
-        let result = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs], 2)?;
+        let result = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs])?;
         let prim: PrimitiveArray = result.into_array().execute(&mut ctx)?;
 
         // Row 0: 5.0 * 5.0 * dot([0.6, 0.8], [0.6, 0.8]) = 25.0, row 1: null.
@@ -754,14 +485,10 @@ mod tests {
     }
 
     #[rstest]
-    #[case::vector(inner_product_vector_lhs(), inner_product_vector_rhs(), 2)]
-    #[case::fixed_shape_tensor(inner_product_tensor_lhs(), inner_product_tensor_rhs(), 2)]
-    fn serde_round_trip(
-        #[case] lhs: ArrayRef,
-        #[case] rhs: ArrayRef,
-        #[case] len: usize,
-    ) -> VortexResult<()> {
-        let original = InnerProduct::try_new_array(lhs.clone(), rhs.clone(), len)?.into_array();
+    #[case::vector(inner_product_vector_lhs(), inner_product_vector_rhs())]
+    #[case::fixed_shape_tensor(inner_product_tensor_lhs(), inner_product_tensor_rhs())]
+    fn serde_round_trip(#[case] lhs: ArrayRef, #[case] rhs: ArrayRef) -> VortexResult<()> {
+        let original = InnerProduct::try_new_array(lhs.clone(), rhs.clone())?.into_array();
 
         let plugin = ScalarFnArrayPlugin::new(InnerProduct);
         let metadata = plugin
@@ -799,787 +526,4 @@ mod tests {
     fn inner_product_tensor_rhs() -> ArrayRef {
         tensor_array(&[2], &[5.0, 6.0, 7.0, 8.0]).expect("valid tensor array")
     }
-
-    // ---- Tests for the `SorfTransform + constant` and `Dict + constant` fast paths ----
-
-    #[allow(
-        clippy::cast_possible_truncation,
-        reason = "tests build small fixtures with deterministic in-range indices"
-    )]
-    mod constant_query_optimizations {
-        use rstest::rstest;
-        use vortex_array::ArrayRef;
-        use vortex_array::IntoArray;
-        use vortex_array::VortexSessionExecute;
-        use vortex_array::arrays::Constant;
-        use vortex_array::arrays::FixedSizeListArray;
-        use vortex_array::arrays::PrimitiveArray;
-        use vortex_array::arrays::ScalarFnArray;
-        use vortex_array::arrays::dict::DictArray;
-        use vortex_array::dtype::DType;
-        use vortex_array::dtype::Nullability;
-        use vortex_array::dtype::PType;
-        use vortex_array::validity::Validity;
-        use vortex_buffer::Buffer;
-        use vortex_error::VortexResult;
-
-        use crate::scalar_fns::inner_product::InnerProduct;
-        use crate::scalar_fns::inner_product::constant_tensor_storage;
-        use crate::scalar_fns::sorf_transform::SorfMatrix;
-        use crate::scalar_fns::sorf_transform::SorfOptions;
-        use crate::scalar_fns::sorf_transform::SorfTransform;
-        use crate::tests::SESSION;
-        use crate::types::vector::Vector;
-        use crate::utils::extract_flat_elements;
-        use crate::utils::test_helpers::literal_vector_array;
-        use crate::utils::test_helpers::vector_array;
-
-        /// Build a `Vector<list_size, f32>` whose storage is `FSL(DictArray(codes: u8, values:
-        /// f32))`. This mirrors the shape that TurboQuant produces as the SorfTransform child.
-        fn dict_vector_f32(list_size: u32, codes: &[u8], values: &[f32]) -> VortexResult<ArrayRef> {
-            let num_rows = codes.len() / list_size as usize;
-            let codes_arr =
-                PrimitiveArray::new::<u8>(Buffer::copy_from(codes), Validity::NonNullable)
-                    .into_array();
-            let values_arr =
-                PrimitiveArray::new::<f32>(Buffer::copy_from(values), Validity::NonNullable)
-                    .into_array();
-            let dict = DictArray::try_new(codes_arr, values_arr)?;
-            let fsl = FixedSizeListArray::try_new(
-                dict.into_array(),
-                list_size,
-                Validity::NonNullable,
-                num_rows,
-            )?;
-            Vector::try_new_vector_array(fsl.into_array())
-        }
-
-        /// Execute an inner product and return the flat `f32` results.
-        fn eval_ip_f32(lhs: ArrayRef, rhs: ArrayRef, len: usize) -> VortexResult<Vec<f32>> {
-            let scalar_fn = InnerProduct::new().erased();
-            let result = ScalarFnArray::try_new(scalar_fn, vec![lhs, rhs], len)?;
-            let mut ctx = SESSION.create_execution_ctx();
-            let prim: PrimitiveArray = result.into_array().execute(&mut ctx)?;
-            Ok(prim.as_slice::<f32>().to_vec())
-        }
-
-        fn assert_close_f32(actual: &[f32], expected: &[f32], tol: f32) {
-            assert_eq!(actual.len(), expected.len(), "length mismatch");
-            for (i, (a, e)) in actual.iter().zip(expected).enumerate() {
-                assert!(
-                    (a - e).abs() < tol,
-                    "row {i}: got {a}, expected {e} (diff = {})",
-                    (a - e).abs()
-                );
-            }
-        }
-
-        /// Build a SorfTransform ScalarFnArray whose child is a `Vector<padded_dim, f32>`
-        /// wrapping `FSL(Dict(codes, values))`. Returns `(sorf_array, codes, values,
-        /// padded_dim)`.
-        fn build_sorf_with_dict_child(
-            dim: u32,
-            num_rows: usize,
-            seed: u64,
-            num_rounds: u8,
-        ) -> VortexResult<(ArrayRef, Vec<u8>, Vec<f32>, usize)> {
-            let padded_dim = (dim as usize).next_power_of_two();
-            // Small hand-picked codebook of 8 f32 centroids.
-            let values: Vec<f32> = vec![-1.5, -1.0, -0.5, -0.1, 0.1, 0.5, 1.0, 1.5];
-            // Deterministic codes in 0..values.len() covering every position.
-            let codes: Vec<u8> = (0..num_rows * padded_dim)
-                .map(|i| (i as u8) % (values.len() as u8))
-                .collect();
-
-            let padded_vector = dict_vector_f32(padded_dim as u32, &codes, &values)?;
-            let sorf_options = SorfOptions {
-                seed,
-                num_rounds,
-                dimensions: dim,
-                element_ptype: PType::F32,
-            };
-            let sorf =
-                SorfTransform::try_new_array(&sorf_options, padded_vector, num_rows)?.into_array();
-            Ok((sorf, codes, values, padded_dim))
-        }
-
-        /// Decode a SorfTransform-wrapped dict-vector to a flat `Vec<f32>` of `num_rows *
-        /// dim` post-rotation, post-truncation values. This is the ground truth against
-        /// which we compare the fast-path result.
-        fn decode_sorf_dict(
-            codes: &[u8],
-            values: &[f32],
-            padded_dim: usize,
-            dim: usize,
-            num_rows: usize,
-            seed: u64,
-            num_rounds: u8,
-        ) -> VortexResult<Vec<f32>> {
-            let rotation = SorfMatrix::try_new_padded(padded_dim, num_rounds as usize, seed)?;
-            let mut padded = vec![0.0f32; padded_dim];
-            let mut rotated = vec![0.0f32; padded_dim];
-            let mut out = Vec::with_capacity(num_rows * dim);
-            for row in 0..num_rows {
-                for j in 0..padded_dim {
-                    padded[j] = values[codes[row * padded_dim + j] as usize];
-                }
-                rotation.inverse_rotate(&padded, &mut rotated);
-                out.extend_from_slice(&rotated[..dim]);
-            }
-            Ok(out)
-        }
-
-        fn naive_dot(a: &[f32], b: &[f32]) -> f32 {
-            a.iter().zip(b.iter()).map(|(&x, &y)| x * y).sum()
-        }
-
-        // ---- Case 1: SorfTransform + Constant pull-through ----
-
-        #[test]
-        fn constant_tensor_storage_accepts_extension_scalar_literal() -> VortexResult<()> {
-            let literal = literal_vector_array(&[1.0f32, 2.0, 3.0], 5);
-            let storage =
-                constant_tensor_storage(&literal).expect("literal vector should be recognized");
-
-            assert_eq!(storage.len(), 5);
-            let const_storage = storage
-                .as_opt::<Constant>()
-                .expect("storage should remain constant-backed");
-            assert!(matches!(
-                const_storage.scalar().dtype(),
-                DType::FixedSizeList(_, 3, Nullability::NonNullable)
-            ));
-
-            let mut ctx = SESSION.create_execution_ctx();
-            let flat = extract_flat_elements(&storage, 3, &mut ctx)?;
-            assert_eq!(flat.row::<f32>(0), &[1.0, 2.0, 3.0]);
-            Ok(())
-        }
-
-        /// Case 1: SorfTransform on LHS, constant query on RHS, with `dim < padded_dim`
-        /// so the zero-padding branch is exercised.
-        #[test]
-        fn case1_sorf_lhs_constant_rhs_padded_gt_dim() -> VortexResult<()> {
-            let dim: u32 = 100;
-            let num_rows = 7usize;
-            let seed = 42u64;
-            let num_rounds = 3u8;
-            let padded_dim = (dim as usize).next_power_of_two();
-            assert!(padded_dim > dim as usize, "test must exercise padding");
-
-            let (sorf_lhs, codes, values, padded_dim_computed) =
-                build_sorf_with_dict_child(dim, num_rows, seed, num_rounds)?;
-            assert_eq!(padded_dim_computed, padded_dim);
-
-            // Query has `dim` elements.
-            let query_elems: Vec<f32> = (0..dim).map(|i| (i as f32 * 0.1).sin()).collect();
-            let const_rhs = Vector::constant_array(&query_elems, num_rows)?;
-
-            // Ground truth: decode LHS to plain f32 vectors, dot each with the query.
-            let decoded = decode_sorf_dict(
-                &codes,
-                &values,
-                padded_dim,
-                dim as usize,
-                num_rows,
-                seed,
-                num_rounds,
-            )?;
-            let expected: Vec<f32> = (0..num_rows)
-                .map(|i| {
-                    naive_dot(
-                        &decoded[i * dim as usize..(i + 1) * dim as usize],
-                        &query_elems,
-                    )
-                })
-                .collect();
-
-            let actual = eval_ip_f32(sorf_lhs, const_rhs, num_rows)?;
-            assert_close_f32(&actual, &expected, 1e-3);
-            Ok(())
-        }
-
-        /// Case 1: SorfTransform on RHS, constant query on LHS (mirrored).
-        #[test]
-        fn case1_constant_lhs_sorf_rhs_mirrored() -> VortexResult<()> {
-            let dim: u32 = 100;
-            let num_rows = 5usize;
-            let seed = 7u64;
-            let num_rounds = 3u8;
-
-            let (sorf, codes, values, padded_dim) =
-                build_sorf_with_dict_child(dim, num_rows, seed, num_rounds)?;
-
-            let query_elems: Vec<f32> = (0..dim).map(|i| (i as f32 * 0.2).cos()).collect();
-            let const_lhs = Vector::constant_array(&query_elems, num_rows)?;
-
-            let decoded = decode_sorf_dict(
-                &codes,
-                &values,
-                padded_dim,
-                dim as usize,
-                num_rows,
-                seed,
-                num_rounds,
-            )?;
-            let expected: Vec<f32> = (0..num_rows)
-                .map(|i| {
-                    naive_dot(
-                        &decoded[i * dim as usize..(i + 1) * dim as usize],
-                        &query_elems,
-                    )
-                })
-                .collect();
-
-            let actual = eval_ip_f32(const_lhs, sorf, num_rows)?;
-            assert_close_f32(&actual, &expected, 1e-3);
-            Ok(())
-        }
-
-        /// Case 1: `dim == padded_dim` (power-of-two, no zero padding).
-        #[test]
-        fn case1_padded_equals_dim() -> VortexResult<()> {
-            let dim: u32 = 128;
-            let num_rows = 4usize;
-            let seed = 11u64;
-            let num_rounds = 3u8;
-
-            let (sorf, codes, values, padded_dim) =
-                build_sorf_with_dict_child(dim, num_rows, seed, num_rounds)?;
-            assert_eq!(padded_dim, dim as usize);
-
-            let query_elems: Vec<f32> = (0..dim).map(|i| i as f32 * 0.01 - 0.5).collect();
-            let const_rhs = Vector::constant_array(&query_elems, num_rows)?;
-
-            let decoded = decode_sorf_dict(
-                &codes,
-                &values,
-                padded_dim,
-                dim as usize,
-                num_rows,
-                seed,
-                num_rounds,
-            )?;
-            let expected: Vec<f32> = (0..num_rows)
-                .map(|i| {
-                    naive_dot(
-                        &decoded[i * dim as usize..(i + 1) * dim as usize],
-                        &query_elems,
-                    )
-                })
-                .collect();
-
-            let actual = eval_ip_f32(sorf, const_rhs, num_rows)?;
-            assert_close_f32(&actual, &expected, 1e-3);
-            Ok(())
-        }
-
-        /// Case 1: empty `len == 0`. The fast path should handle this without exploding.
-        #[test]
-        fn case1_empty_len_zero() -> VortexResult<()> {
-            let dim: u32 = 100;
-            let num_rows = 0usize;
-            let seed = 42u64;
-            let num_rounds = 3u8;
-
-            let (sorf, _codes, _values, _padded_dim) =
-                build_sorf_with_dict_child(dim, num_rows, seed, num_rounds)?;
-
-            let query_elems: Vec<f32> = vec![0.0; dim as usize];
-            let const_rhs = Vector::constant_array(&query_elems, num_rows)?;
-
-            let actual = eval_ip_f32(sorf, const_rhs, num_rows)?;
-            assert_eq!(actual.len(), 0);
-            Ok(())
-        }
-
-        // ---- Case 2: Dict + Constant direct-lookup path ----
-
-        /// Case 2: Vector[FSL[Dict(u8, f32)]] on LHS, constant query on RHS.
-        #[test]
-        fn case2_dict_lhs_constant_rhs_matches_naive() -> VortexResult<()> {
-            let list_size: u32 = 8;
-            let num_rows = 10usize;
-            // 8 centroids, tiny table.
-            let values: Vec<f32> = vec![-1.0, -0.5, -0.25, -0.1, 0.1, 0.25, 0.5, 1.0];
-            // Deterministic codes.
-            let codes: Vec<u8> = (0..num_rows * list_size as usize)
-                .map(|i| (i as u8) % (values.len() as u8))
-                .collect();
-            let dict_lhs = dict_vector_f32(list_size, &codes, &values)?;
-
-            let query: Vec<f32> = (0..list_size).map(|i| (i as f32 + 1.0) * 0.3).collect();
-            let const_rhs = Vector::constant_array(&query, num_rows)?;
-
-            let expected: Vec<f32> = (0..num_rows)
-                .map(|row| {
-                    let mut acc = 0.0f32;
-                    for j in 0..list_size as usize {
-                        let k = codes[row * list_size as usize + j] as usize;
-                        acc += query[j] * values[k];
-                    }
-                    acc
-                })
-                .collect();
-
-            let actual = eval_ip_f32(dict_lhs, const_rhs, num_rows)?;
-            assert_close_f32(&actual, &expected, 1e-5);
-            Ok(())
-        }
-
-        /// Case 2: constant query on LHS, dict column on RHS (mirrored).
-        #[test]
-        fn case2_constant_lhs_dict_rhs_mirrored() -> VortexResult<()> {
-            let list_size: u32 = 4;
-            let num_rows = 6usize;
-            let values: Vec<f32> = vec![0.1, 0.4, 0.7, 1.0];
-            let codes: Vec<u8> = (0..num_rows * list_size as usize)
-                .map(|i| ((i * 3) as u8) % (values.len() as u8))
-                .collect();
-            let dict_rhs = dict_vector_f32(list_size, &codes, &values)?;
-
-            let query: Vec<f32> = vec![0.5, -1.0, 2.5, -0.25];
-            let const_lhs = Vector::constant_array(&query, num_rows)?;
-
-            let expected: Vec<f32> = (0..num_rows)
-                .map(|row| {
-                    let mut acc = 0.0f32;
-                    for j in 0..list_size as usize {
-                        let k = codes[row * list_size as usize + j] as usize;
-                        acc += query[j] * values[k];
-                    }
-                    acc
-                })
-                .collect();
-
-            let actual = eval_ip_f32(const_lhs, dict_rhs, num_rows)?;
-            assert_close_f32(&actual, &expected, 1e-5);
-            Ok(())
-        }
-
-        /// Case 2: dict with `u16` codes (and hence more than 256 values) falls through to
-        /// the standard path but still produces the correct result. The direct-lookup path
-        /// only handles `u8` codes today.
-        #[test]
-        fn case2_u16_codes_falls_through() -> VortexResult<()> {
-            let list_size: u32 = 4;
-            let num_rows = 3usize;
-            let num_values = 300usize;
-            let values: Vec<f32> = (0..num_values).map(|i| i as f32 * 0.01).collect();
-            // Codes must be u16 because 300 > 255. dict_vector_f32 only supports u8 so we
-            // build the dict by hand here.
-            let codes_u16: Vec<u16> = (0..(num_rows * 4))
-                .map(|i| (i % num_values) as u16)
-                .collect();
-            let codes_arr =
-                PrimitiveArray::new::<u16>(Buffer::copy_from(codes_u16), Validity::NonNullable)
-                    .into_array();
-            let values_arr =
-                PrimitiveArray::new::<f32>(Buffer::copy_from(&values), Validity::NonNullable)
-                    .into_array();
-            let dict = DictArray::try_new(codes_arr, values_arr)?;
-            let fsl = FixedSizeListArray::try_new(
-                dict.into_array(),
-                list_size,
-                Validity::NonNullable,
-                num_rows,
-            )?;
-            let dict_lhs = Vector::try_new_vector_array(fsl.into_array())?;
-
-            let query: Vec<f32> = vec![1.0, 2.0, 3.0, 4.0];
-            let const_rhs = Vector::constant_array(&query, num_rows)?;
-
-            // Build expected by decoding by hand.
-            let expected: Vec<f32> = (0..num_rows)
-                .map(|row| {
-                    let mut acc = 0.0f32;
-                    for j in 0..4 {
-                        let code = (row * 4 + j) % num_values;
-                        acc += query[j] * values[code];
-                    }
-                    acc
-                })
-                .collect();
-
-            let actual = eval_ip_f32(dict_lhs, const_rhs, num_rows)?;
-            assert_close_f32(&actual, &expected, 1e-5);
-            Ok(())
-        }
-
-        /// Case 2: plain (non-dict) FSL with a constant RHS falls through to the standard
-        /// path and produces the correct result.
-        #[test]
-        fn case2_plain_fsl_falls_through() -> VortexResult<()> {
-            let dim: u32 = 4;
-            let num_rows = 3usize;
-            let lhs_elems: Vec<f32> = (0..num_rows * dim as usize)
-                .map(|i| i as f32 * 0.25)
-                .collect();
-            let plain_lhs = vector_array(dim, &lhs_elems)?;
-
-            let query: Vec<f32> = vec![1.0, 2.0, 3.0, 4.0];
-            let const_rhs = Vector::constant_array(&query, num_rows)?;
-
-            let expected: Vec<f32> = (0..num_rows)
-                .map(|row| {
-                    naive_dot(
-                        &lhs_elems[row * dim as usize..(row + 1) * dim as usize],
-                        &query,
-                    )
-                })
-                .collect();
-
-            let actual = eval_ip_f32(plain_lhs, const_rhs, num_rows)?;
-            assert_close_f32(&actual, &expected, 1e-5);
-            Ok(())
-        }
-
-        /// Case 2: empty `len == 0` fast path returns an empty primitive array without
-        /// touching the codes buffer.
-        #[test]
-        fn case2_empty_len_zero() -> VortexResult<()> {
-            let list_size: u32 = 4;
-            let num_rows = 0usize;
-            let values: Vec<f32> = vec![0.0, 1.0, 2.0, 3.0];
-            let codes: Vec<u8> = Vec::new();
-            let dict_lhs = dict_vector_f32(list_size, &codes, &values)?;
-
-            let query: Vec<f32> = vec![0.0; 4];
-            let const_rhs = Vector::constant_array(&query, num_rows)?;
-
-            let actual = eval_ip_f32(dict_lhs, const_rhs, num_rows)?;
-            assert_eq!(actual.len(), 0);
-            Ok(())
-        }
-
-        /// Case 1 + Case 2 end-to-end: the SorfTransform-wrapped dict column hits Case 1
-        /// then Case 2 via recursive execution.
-        #[test]
-        fn end_to_end_sorf_plus_dict_cosine_path() -> VortexResult<()> {
-            let dim: u32 = 100;
-            let num_rows = 9usize;
-            let seed = 99u64;
-            let num_rounds = 3u8;
-
-            let (sorf, codes, values, padded_dim) =
-                build_sorf_with_dict_child(dim, num_rows, seed, num_rounds)?;
-
-            let query_elems: Vec<f32> = (0..dim).map(|i| ((i as f32) * 0.15).sin() * 0.4).collect();
-            let const_rhs = Vector::constant_array(&query_elems, num_rows)?;
-
-            // Ground truth via full decode + naive dot.
-            let decoded = decode_sorf_dict(
-                &codes,
-                &values,
-                padded_dim,
-                dim as usize,
-                num_rows,
-                seed,
-                num_rounds,
-            )?;
-            let expected: Vec<f32> = (0..num_rows)
-                .map(|i| {
-                    naive_dot(
-                        &decoded[i * dim as usize..(i + 1) * dim as usize],
-                        &query_elems,
-                    )
-                })
-                .collect();
-
-            let actual = eval_ip_f32(sorf, const_rhs, num_rows)?;
-            assert_close_f32(&actual, &expected, 1e-3);
-            Ok(())
-        }
-
-        // ---- Additional correctness / stress tests (all with loose tolerances) ----
-
-        /// A tiny in-place xorshift64 PRNG so these tests don't depend on `rand`. Producing
-        /// deterministic pseudo-random f32 values lets the correctness checks exercise
-        /// realistic data instead of smooth sin/cos patterns.
-        struct XorShift64(u64);
-
-        impl XorShift64 {
-            fn new(seed: u64) -> Self {
-                // Any nonzero seed is fine; xorshift fixed-points at 0.
-                Self(seed.wrapping_add(0x9E37_79B9_7F4A_7C15))
-            }
-
-            fn next_u64(&mut self) -> u64 {
-                let mut x = self.0;
-                x ^= x << 13;
-                x ^= x >> 7;
-                x ^= x << 17;
-                self.0 = x;
-                x
-            }
-
-            /// Uniform f32 in `[-1.0, 1.0)`.
-            fn next_f32(&mut self) -> f32 {
-                // Top 24 bits -> mantissa in [0, 1), then shift to [-1, 1).
-                let bits = (self.next_u64() >> 40) as u32; // 24 bits
-                (bits as f32) / (1u32 << 24) as f32 * 2.0 - 1.0
-            }
-        }
-
-        /// Case 2 stress: u8-coded dict with 200 centroids (formerly blocked by the
-        /// `values.len() <= 256` gate). The direct-lookup path must now handle it.
-        #[test]
-        fn case2_large_u8_codebook_direct_lookup() -> VortexResult<()> {
-            let list_size: u32 = 16;
-            let num_rows = 20usize;
-            let num_centroids = 200usize;
-            assert!(num_centroids > 8 && num_centroids <= 256);
-
-            let mut rng = XorShift64::new(0xDEAD_BEEF);
-            let values: Vec<f32> = (0..num_centroids).map(|_| rng.next_f32()).collect();
-            let codes: Vec<u8> = (0..num_rows * list_size as usize)
-                .map(|_| (rng.next_u64() % num_centroids as u64) as u8)
-                .collect();
-
-            let dict_lhs = dict_vector_f32(list_size, &codes, &values)?;
-            let query: Vec<f32> = (0..list_size).map(|_| rng.next_f32()).collect();
-            let const_rhs = Vector::constant_array(&query, num_rows)?;
-
-            let expected: Vec<f32> = (0..num_rows)
-                .map(|row| {
-                    let mut acc = 0.0f32;
-                    for j in 0..list_size as usize {
-                        let k = codes[row * list_size as usize + j] as usize;
-                        acc += query[j] * values[k];
-                    }
-                    acc
-                })
-                .collect();
-
-            let actual = eval_ip_f32(dict_lhs, const_rhs, num_rows)?;
-            assert_close_f32(&actual, &expected, 1e-4);
-            Ok(())
-        }
-
-        /// Parameterized sweep over the full `InnerProduct(SorfTransform(Vector[FSL(Dict)]),
-        /// ConstantArray)` tree, exercising the case 1 + case 2 chain for a realistic mix
-        /// of dimensions, row counts, seeds, and number of SORF rounds. Tolerance is
-        /// deliberately loose because the rewrite introduces an f32-domain rotation that
-        /// accumulates a small numerical drift versus a naive decode.
-        #[rstest]
-        #[case::small_no_pad(128, 11, 1, 1)]
-        #[case::small_no_pad_rounds3(128, 23, 1_234, 3)]
-        #[case::small_padded(100, 17, 42, 3)]
-        #[case::mid_padded(200, 13, 2024, 3)]
-        #[case::mid_power_of_two(256, 31, 7, 3)]
-        #[case::larger_padded(300, 9, 99, 3)]
-        #[case::max_rounds(128, 5, 31_415, 5)]
-        fn case1_sorf_random_sweep(
-            #[case] dim: u32,
-            #[case] num_rows: usize,
-            #[case] seed: u64,
-            #[case] num_rounds: u8,
-        ) -> VortexResult<()> {
-            let (sorf, codes, values, padded_dim) =
-                build_sorf_with_dict_child(dim, num_rows, seed, num_rounds)?;
-
-            // Use a pseudo-random query with both positive and negative entries so the sum
-            // has cancellation.
-            let mut rng = XorShift64::new(seed ^ 0xABCD_1234);
-            let query: Vec<f32> = (0..dim).map(|_| rng.next_f32()).collect();
-            let const_rhs = Vector::constant_array(&query, num_rows)?;
-
-            let decoded = decode_sorf_dict(
-                &codes,
-                &values,
-                padded_dim,
-                dim as usize,
-                num_rows,
-                seed,
-                num_rounds,
-            )?;
-            let expected: Vec<f32> = (0..num_rows)
-                .map(|i| naive_dot(&decoded[i * dim as usize..(i + 1) * dim as usize], &query))
-                .collect();
-
-            // Loose tolerance: the sorf transform works in f32 with a k-round butterfly, so
-            // the rewrite path and the decoded path accumulate slightly different rounding
-            // even though the math is equivalent in exact arithmetic.
-            let actual = eval_ip_f32(sorf, const_rhs, num_rows)?;
-            assert_close_f32(&actual, &expected, 1e-2);
-            Ok(())
-        }
-
-        /// Parameterized sweep over plain `Vector[FSL(Dict(u8, f32))]` + constant query,
-        /// without SorfTransform in the mix. This directly exercises case 2 across a
-        /// variety of list sizes, num_rows, and codebook sizes including large ones that
-        /// the old `<= 256` gate would have rejected.
-        #[rstest]
-        #[case::small(4, 7, 8)]
-        #[case::medium(16, 50, 64)]
-        #[case::larger(32, 100, 150)]
-        #[case::very_large_codebook(8, 25, 250)]
-        fn case2_random_sweep(
-            #[case] list_size: u32,
-            #[case] num_rows: usize,
-            #[case] num_centroids: usize,
-        ) -> VortexResult<()> {
-            let mut rng = XorShift64::new((list_size as u64) * 31 + num_rows as u64);
-            let values: Vec<f32> = (0..num_centroids).map(|_| rng.next_f32()).collect();
-            assert!(num_centroids <= 256, "u8 codes cap at 256 centroids");
-            let codes: Vec<u8> = (0..num_rows * list_size as usize)
-                .map(|_| (rng.next_u64() % num_centroids as u64) as u8)
-                .collect();
-
-            let dict_lhs = dict_vector_f32(list_size, &codes, &values)?;
-            let query: Vec<f32> = (0..list_size).map(|_| rng.next_f32()).collect();
-            let const_rhs = Vector::constant_array(&query, num_rows)?;
-
-            let expected: Vec<f32> = (0..num_rows)
-                .map(|row| {
-                    let mut acc = 0.0f32;
-                    for j in 0..list_size as usize {
-                        let k = codes[row * list_size as usize + j] as usize;
-                        acc += query[j] * values[k];
-                    }
-                    acc
-                })
-                .collect();
-
-            // Tight tolerance here because no SorfTransform rotation is involved — the
-            // arithmetic should agree bit-for-bit up to float reassociation.
-            let actual = eval_ip_f32(dict_lhs, const_rhs, num_rows)?;
-            assert_close_f32(&actual, &expected, 1e-4);
-            Ok(())
-        }
-
-        /// End-to-end regression: for a plausible vector-search configuration (SORF rounds
-        /// = 3, dim = 128, num_rows = 64, u8 codes, 64 centroids), the fast-path result
-        /// must track a fully naive computation within 1e-2.
-        #[test]
-        fn end_to_end_dim128_rows64_bit6_regression() -> VortexResult<()> {
-            let dim: u32 = 128;
-            let num_rows = 64usize;
-            let seed = 0xFACE_F00D;
-            let num_rounds = 3u8;
-
-            // Use 64 centroids (6 bits), a typical TurboQuant configuration.
-            let num_centroids = 64usize;
-            let padded_dim = (dim as usize).next_power_of_two();
-            let mut rng = XorShift64::new(seed);
-            let values: Vec<f32> = (0..num_centroids).map(|_| rng.next_f32()).collect();
-            let codes: Vec<u8> = (0..num_rows * padded_dim)
-                .map(|_| (rng.next_u64() % num_centroids as u64) as u8)
-                .collect();
-
-            let padded_vector = dict_vector_f32(padded_dim as u32, &codes, &values)?;
-            let sorf_options = SorfOptions {
-                seed,
-                num_rounds,
-                dimensions: dim,
-                element_ptype: PType::F32,
-            };
-            let sorf =
-                SorfTransform::try_new_array(&sorf_options, padded_vector, num_rows)?.into_array();
-
-            let query: Vec<f32> = (0..dim).map(|_| rng.next_f32()).collect();
-            let const_rhs = Vector::constant_array(&query, num_rows)?;
-
-            let decoded = decode_sorf_dict(
-                &codes,
-                &values,
-                padded_dim,
-                dim as usize,
-                num_rows,
-                seed,
-                num_rounds,
-            )?;
-            let expected: Vec<f32> = (0..num_rows)
-                .map(|i| naive_dot(&decoded[i * dim as usize..(i + 1) * dim as usize], &query))
-                .collect();
-
-            let actual = eval_ip_f32(sorf, const_rhs, num_rows)?;
-            assert_close_f32(&actual, &expected, 1e-2);
-
-            // Also verify the max relative error is small. The SORF rotation does not
-            // amplify error, so both measures should be bounded.
-            for (i, (a, e)) in actual.iter().zip(expected.iter()).enumerate() {
-                let denom = e.abs().max(1.0);
-                let rel = (a - e).abs() / denom;
-                assert!(
-                    rel < 1e-3,
-                    "row {i}: rel err {rel} too large (a={a}, e={e})"
-                );
-            }
-            Ok(())
-        }
-
-        /// Case 1 + Case 2 end-to-end with varying `num_rounds`. The rotation becomes
-        /// progressively more chaotic as rounds increase, so this catches any off-by-one
-        /// bug in the round-indexing that would not show up in the 3-round default.
-        #[rstest]
-        #[case(1)]
-        #[case(2)]
-        #[case(3)]
-        #[case(4)]
-        #[case(5)]
-        fn case1_various_num_rounds(#[case] num_rounds: u8) -> VortexResult<()> {
-            let dim: u32 = 128;
-            let num_rows = 8usize;
-            let seed = 0x1234_5678;
-
-            let (sorf, codes, values, padded_dim) =
-                build_sorf_with_dict_child(dim, num_rows, seed, num_rounds)?;
-
-            let mut rng = XorShift64::new(seed ^ (num_rounds as u64));
-            let query: Vec<f32> = (0..dim).map(|_| rng.next_f32()).collect();
-            let const_rhs = Vector::constant_array(&query, num_rows)?;
-
-            let decoded = decode_sorf_dict(
-                &codes,
-                &values,
-                padded_dim,
-                dim as usize,
-                num_rows,
-                seed,
-                num_rounds,
-            )?;
-            let expected: Vec<f32> = (0..num_rows)
-                .map(|i| naive_dot(&decoded[i * dim as usize..(i + 1) * dim as usize], &query))
-                .collect();
-
-            let actual = eval_ip_f32(sorf, const_rhs, num_rows)?;
-            assert_close_f32(&actual, &expected, 1e-2);
-            Ok(())
-        }
-
-        /// Swap LHS and RHS on the full tree to prove the side-detection and the scalar
-        /// argument-order handling are symmetric for both cases simultaneously.
-        #[test]
-        fn end_to_end_constant_lhs_sorf_rhs_mirrored() -> VortexResult<()> {
-            let dim: u32 = 256;
-            let num_rows = 12usize;
-            let seed = 0xBEEF_CAFE;
-            let num_rounds = 3u8;
-
-            let (sorf, codes, values, padded_dim) =
-                build_sorf_with_dict_child(dim, num_rows, seed, num_rounds)?;
-
-            let mut rng = XorShift64::new(seed);
-            let query: Vec<f32> = (0..dim).map(|_| rng.next_f32()).collect();
-            let const_lhs = Vector::constant_array(&query, num_rows)?;
-
-            let decoded = decode_sorf_dict(
-                &codes,
-                &values,
-                padded_dim,
-                dim as usize,
-                num_rows,
-                seed,
-                num_rounds,
-            )?;
-            let expected: Vec<f32> = (0..num_rows)
-                .map(|i| naive_dot(&decoded[i * dim as usize..(i + 1) * dim as usize], &query))
-                .collect();
-
-            let actual = eval_ip_f32(const_lhs, sorf, num_rows)?;
-            assert_close_f32(&actual, &expected, 1e-2);
-            Ok(())
-        }
-    }
 }
diff --git a/vortex-tensor/src/scalar_fns/l2_denorm.rs b/vortex-tensor/src/scalar_fns/l2_denorm.rs
index 00ad7d75e8a..4f4159b4a21 100644
--- a/vortex-tensor/src/scalar_fns/l2_denorm.rs
+++ b/vortex-tensor/src/scalar_fns/l2_denorm.rs
@@ -54,6 +54,7 @@ use vortex_error::vortex_ensure;
 use vortex_error::vortex_ensure_eq;
 use vortex_error::vortex_err;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 
 use crate::matcher::AnyTensor;
 use crate::scalar_fns::l2_norm::L2Norm;
@@ -110,13 +111,12 @@ impl L2Denorm {
     pub fn try_new_array(
         normalized: ArrayRef,
         norms: ArrayRef,
-        len: usize,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<ScalarFnArray> {
         validate_l2_normalized_rows_against_norms(&normalized, Some(&norms), ctx)?;
 
         // SAFETY: We just validated that it is normalized.
-        unsafe { Self::new_array_unchecked(normalized, norms, len) }
+        unsafe { Self::new_array_unchecked(normalized, norms) }
     }
 
     /// Constructs an [`L2Denorm`] array without validating that the `normalized` child is actually
@@ -139,9 +139,8 @@ impl L2Denorm {
     pub unsafe fn new_array_unchecked(
         normalized: ArrayRef,
         norms: ArrayRef,
-        len: usize,
     ) -> VortexResult<ScalarFnArray> {
-        ScalarFnArray::try_new(L2Denorm::new().erased(), vec![normalized, norms], len)
+        ScalarFnArray::try_new(L2Denorm::new().erased(), vec![normalized, norms])
     }
 }
 
@@ -149,7 +148,8 @@ impl ScalarFnVTable for L2Denorm {
     type Options = EmptyOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.tensor.l2_denorm")
+        static ID: CachedId = CachedId::new("vortex.tensor.l2_denorm");
+        *ID
     }
 
     fn arity(&self, _options: &Self::Options) -> Arity {
@@ -404,7 +404,7 @@ fn execute_l2_denorm_constant_norms(
 ///
 /// Rows that are null in the original input are **zeroed out** in the normalized output. This is
 /// necessary because null rows may have undefined (garbage) physical storage values, and we do not
-/// want to let those propagate into downstream encodings (like TurboQuant).
+/// want to let those propagate into downstream lossy encodings.
 ///
 /// # Nullability
 ///
@@ -430,7 +430,7 @@ pub fn normalize_as_l2_denorm(
     }
 
     // Calculate the norms of the vectors.
-    let norms_sfn = L2Norm::try_new_array(input.clone(), row_count)?;
+    let norms_sfn = L2Norm::try_new_array(input.clone())?;
     let norms_array: ArrayRef = norms_sfn.into_array().execute(ctx)?;
     let primitive_norms: PrimitiveArray = norms_array.clone().execute(ctx)?;
     let norms_validity = primitive_norms.validity()?;
@@ -439,6 +439,10 @@ pub fn normalize_as_l2_denorm(
     let normalized_dtype = input.dtype().as_nonnullable();
     let flat = extract_flat_elements(input.storage_array(), tensor_flat_size, ctx)?;
 
+    // Resolve validity to a mask once rather than probing it per row (each `Validity::is_valid`
+    // executes a scalar for array-backed validity).
+    let norms_valid = norms_validity.execute_mask(row_count, ctx)?;
+
     // Normalize all of the vectors.
     let normalized = match_each_float_ptype!(flat.ptype(), |T| {
         let norm_values = primitive_norms.as_slice::<T>();
@@ -446,7 +450,7 @@ pub fn normalize_as_l2_denorm(
         let total_elements = row_count * tensor_flat_size;
         let mut elements = BufferMut::<T>::with_capacity(total_elements);
         for i in 0..row_count {
-            let is_valid = norms_validity.is_valid(i)?;
+            let is_valid = norms_valid.value(i);
             let norm = norm_values[i];
 
             // SAFETY: We allocated `row_count * tensor_flat_size` capacity and push exactly
@@ -481,7 +485,7 @@ pub fn normalize_as_l2_denorm(
     //   construction.
     // - Null rows are zeroed out above to avoid propagating arbitrary physical storage values into
     //   downstream lossy encodings.
-    unsafe { L2Denorm::new_array_unchecked(normalized, norms_array, row_count) }
+    unsafe { L2Denorm::new_array_unchecked(normalized, norms_array) }
 }
 
 /// Attempts to build an [`L2Denorm`] whose two children are both [`ConstantArray`]s by eagerly
@@ -564,7 +568,7 @@ pub(crate) fn try_build_constant_l2_denorm(
     // point tolerance) or all zeros when `||v|| == 0`. Stored norms are non-negative by
     // construction (`sqrt`). These are exactly the invariants required by
     // [`L2Denorm::new_array_unchecked`].
-    let wrapped = unsafe { L2Denorm::new_array_unchecked(normalized_ext, norms_array, len)? };
+    let wrapped = unsafe { L2Denorm::new_array_unchecked(normalized_ext, norms_array)? };
     Ok(Some(wrapped))
 }
 
@@ -635,12 +639,14 @@ pub fn validate_l2_normalized_rows_against_norms(
         Some(norms) => normalized_validity.and(norms.validity()?)?,
         None => normalized_validity,
     };
+    // Resolve validity to a mask once rather than probing it per row.
+    let combined_valid = combined_validity.execute_mask(row_count, ctx)?;
 
     match_each_float_ptype!(element_ptype, |T| {
         let stored_norms = norms.as_ref().map(|norms| norms.as_slice::<T>());
 
         for i in 0..row_count {
-            if !combined_validity.is_valid(i)? {
+            if !combined_valid.value(i) {
                 continue;
             }
 
@@ -763,9 +769,9 @@ mod tests {
     use crate::utils::test_helpers::vector_array;
 
     /// Evaluates L2 denorm on a tensor/vector array and returns the executed array.
-    fn eval_l2_denorm(normalized: ArrayRef, norms: ArrayRef, len: usize) -> VortexResult<ArrayRef> {
+    fn eval_l2_denorm(normalized: ArrayRef, norms: ArrayRef) -> VortexResult<ArrayRef> {
         let mut ctx = SESSION.create_execution_ctx();
-        let result = L2Denorm::try_new_array(normalized, norms, len, &mut ctx)?;
+        let result = L2Denorm::try_new_array(normalized, norms, &mut ctx)?;
         result.into_array().execute(&mut ctx)
     }
 
@@ -805,7 +811,7 @@ mod tests {
     fn l2_denorm_vectors() -> VortexResult<()> {
         let lhs = vector_array(3, &[0.6, 0.8, 0.0, 0.0, 0.0, 0.0])?;
         let rhs = PrimitiveArray::from_iter([5.0f64, 0.0]).into_array();
-        let actual = eval_l2_denorm(lhs, rhs, 2)?;
+        let actual = eval_l2_denorm(lhs, rhs)?;
         let expected = vector_array(3, &[3.0, 4.0, 0.0, 0.0, 0.0, 0.0])?;
 
         assert_tensor_arrays_eq(actual, expected)?;
@@ -816,7 +822,7 @@ mod tests {
     fn l2_denorm_fixed_shape_tensors() -> VortexResult<()> {
         let lhs = tensor_array(&[2, 2], &[0.5, 0.5, 0.5, 0.5, 1.0, 0.0, 0.0, 0.0])?;
         let rhs = PrimitiveArray::from_iter([4.0f64, 2.0]).into_array();
-        let actual = eval_l2_denorm(lhs, rhs, 2)?;
+        let actual = eval_l2_denorm(lhs, rhs)?;
         let expected = tensor_array(&[2, 2], &[2.0, 2.0, 2.0, 2.0, 2.0, 0.0, 0.0, 0.0])?;
 
         assert_tensor_arrays_eq(actual, expected)?;
@@ -830,7 +836,7 @@ mod tests {
 
         let rhs = PrimitiveArray::from_option_iter([Some(5.0f64), Some(2.0), None]).into_array();
         let mut ctx = SESSION.create_execution_ctx();
-        let actual: ExtensionArray = eval_l2_denorm(lhs, rhs, 3)?.execute(&mut ctx)?;
+        let actual: ExtensionArray = eval_l2_denorm(lhs, rhs)?.execute(&mut ctx)?;
         let storage: FixedSizeListArray = actual.storage_array().clone().execute(&mut ctx)?;
         let elements: PrimitiveArray = storage.elements().clone().execute(&mut ctx)?;
 
@@ -847,7 +853,7 @@ mod tests {
         let rhs = PrimitiveArray::from_iter([1.0f64, 1.0]).into_array();
 
         let mut ctx = SESSION.create_execution_ctx();
-        let result = L2Denorm::try_new_array(lhs, rhs, 2, &mut ctx);
+        let result = L2Denorm::try_new_array(lhs, rhs, &mut ctx);
         assert!(result.is_err());
     }
 
@@ -857,7 +863,7 @@ mod tests {
         let rhs = PrimitiveArray::from_iter([1.0f64, 1.0]).into_array();
 
         let mut ctx = SESSION.create_execution_ctx();
-        let result = L2Denorm::try_new_array(lhs, rhs, 2, &mut ctx);
+        let result = L2Denorm::try_new_array(lhs, rhs, &mut ctx);
         assert!(result.is_err());
         Ok(())
     }
@@ -868,7 +874,7 @@ mod tests {
         let rhs = PrimitiveArray::from_iter([1.0f64, 1.0]).into_array();
 
         let mut ctx = SESSION.create_execution_ctx();
-        let result = L2Denorm::try_new_array(lhs, rhs, 2, &mut ctx);
+        let result = L2Denorm::try_new_array(lhs, rhs, &mut ctx);
         assert!(result.is_err());
         Ok(())
     }
@@ -879,7 +885,7 @@ mod tests {
         let rhs = PrimitiveArray::from_iter([1.0f32, 1.0]).into_array();
 
         let mut ctx = SESSION.create_execution_ctx();
-        let result = L2Denorm::try_new_array(lhs, rhs, 2, &mut ctx);
+        let result = L2Denorm::try_new_array(lhs, rhs, &mut ctx);
         assert!(result.is_err());
         Ok(())
     }
@@ -908,7 +914,7 @@ mod tests {
         let norms = PrimitiveArray::from_iter([5.0f64, 1.0]).into_array();
         let mut ctx = SESSION.create_execution_ctx();
 
-        let result = L2Denorm::try_new_array(normalized, norms, 2, &mut ctx);
+        let result = L2Denorm::try_new_array(normalized, norms, &mut ctx);
         assert!(result.is_err());
         Ok(())
     }
@@ -919,7 +925,7 @@ mod tests {
         let norms = PrimitiveArray::from_iter([0.0f64, 0.0]).into_array();
         let mut ctx = SESSION.create_execution_ctx();
 
-        let result = L2Denorm::try_new_array(normalized, norms, 2, &mut ctx);
+        let result = L2Denorm::try_new_array(normalized, norms, &mut ctx);
         assert!(result.is_err());
         Ok(())
     }
@@ -930,7 +936,7 @@ mod tests {
         let norms = PrimitiveArray::from_iter([1.0f64, -1.0]).into_array();
         let mut ctx = SESSION.create_execution_ctx();
 
-        let result = L2Denorm::try_new_array(normalized, norms, 2, &mut ctx);
+        let result = L2Denorm::try_new_array(normalized, norms, &mut ctx);
         assert!(result.is_err());
         Ok(())
     }
@@ -940,7 +946,7 @@ mod tests {
         let normalized = vector_array(2, &[3.0, 4.0, 1.0, 0.0])?;
         let norms = PrimitiveArray::from_iter([5.0f64, 1.0]).into_array();
 
-        let result = unsafe { L2Denorm::new_array_unchecked(normalized, norms, 2) };
+        let result = unsafe { L2Denorm::new_array_unchecked(normalized, norms) };
         assert!(result.is_ok());
         Ok(())
     }
@@ -1054,7 +1060,7 @@ mod tests {
         let normalized = vector_array(3, &[1.0, 0.0, 0.0, 0.0, 1.0, 0.0])?;
         let norms = constant_f64_norms(1.0, 2);
 
-        let actual = eval_l2_denorm(normalized.clone(), norms, 2)?;
+        let actual = eval_l2_denorm(normalized.clone(), norms)?;
         assert_tensor_arrays_eq(actual, normalized)?;
         Ok(())
     }
@@ -1066,7 +1072,7 @@ mod tests {
         let normalized = vector_array(3, &[1.0, 0.0, 0.0, 0.0, 1.0, 0.0])?;
         let norms = constant_f64_norms(1.0 + 1e-12, 2);
 
-        let actual = eval_l2_denorm(normalized.clone(), norms, 2)?;
+        let actual = eval_l2_denorm(normalized.clone(), norms)?;
         assert_tensor_arrays_eq(actual, normalized)?;
         Ok(())
     }
@@ -1078,7 +1084,7 @@ mod tests {
         let normalized = vector_array(3, &[0.6, 0.8, 0.0, 1.0, 0.0, 0.0])?;
         let norms = constant_f64_norms(5.0, 2);
 
-        let actual = eval_l2_denorm(normalized, norms, 2)?;
+        let actual = eval_l2_denorm(normalized, norms)?;
         let expected = vector_array(3, &[3.0, 4.0, 0.0, 5.0, 0.0, 0.0])?;
         assert_tensor_arrays_eq(actual, expected)?;
         Ok(())
@@ -1091,7 +1097,7 @@ mod tests {
         let normalized = tensor_array(&[2, 2], &[0.5, 0.5, 0.5, 0.5, 1.0, 0.0, 0.0, 0.0])?;
         let norms = constant_f64_norms(4.0, 2);
 
-        let actual = eval_l2_denorm(normalized, norms, 2)?;
+        let actual = eval_l2_denorm(normalized, norms)?;
         let expected = tensor_array(&[2, 2], &[2.0, 2.0, 2.0, 2.0, 4.0, 0.0, 0.0, 0.0])?;
         assert_tensor_arrays_eq(actual, expected)?;
         Ok(())
diff --git a/vortex-tensor/src/scalar_fns/l2_norm.rs b/vortex-tensor/src/scalar_fns/l2_norm.rs
index d760c3429bd..aa85ab4c78e 100644
--- a/vortex-tensor/src/scalar_fns/l2_norm.rs
+++ b/vortex-tensor/src/scalar_fns/l2_norm.rs
@@ -41,6 +41,7 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_ensure_eq;
 use vortex_error::vortex_err;
 use vortex_session::VortexSession;
+use vortex_session::registry::CachedId;
 
 use crate::matcher::AnyTensor;
 use crate::scalar_fns::l2_denorm::L2Denorm;
@@ -56,7 +57,7 @@ use crate::utils::validate_tensor_float_input;
 /// column of the same float type.
 ///
 /// When the input is wrapped in [`L2Denorm`], this operator treats the stored norms as
-/// authoritative. For lossy encodings such as TurboQuant, that means `L2Norm` may intentionally
+/// authoritative. For lossy encodings, that means `L2Norm` may intentionally
 /// read the stored norms instead of re-deriving them from fully decoded coordinates. That behavior
 /// is part of the lossy storage contract, not a separate lossy-compute mode.
 #[derive(Clone)]
@@ -74,8 +75,8 @@ impl L2Norm {
     ///
     /// Returns an error if the [`ScalarFnArray`] cannot be constructed (e.g. due to dtype
     /// mismatches).
-    pub fn try_new_array(child: ArrayRef, len: usize) -> VortexResult<ScalarFnArray> {
-        ScalarFnArray::try_new(L2Norm::new().erased(), vec![child], len)
+    pub fn try_new_array(child: ArrayRef) -> VortexResult<ScalarFnArray> {
+        ScalarFnArray::try_new(L2Norm::new().erased(), vec![child])
     }
 }
 
@@ -83,7 +84,8 @@ impl ScalarFnVTable for L2Norm {
     type Options = EmptyOptions;
 
     fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.tensor.l2_norm")
+        static ID: CachedId = CachedId::new("vortex.tensor.l2_norm");
+        *ID
     }
 
     fn arity(&self, _options: &Self::Options) -> Arity {
@@ -125,7 +127,7 @@ impl ScalarFnVTable for L2Norm {
         let norm_dtype = DType::Primitive(element_ptype, ext.nullability());
 
         // L2Norm(L2Denorm(normalized, norms)) is defined to read back the authoritative stored
-        // norms. Exact callers of lossy encodings like TurboQuant opt into that storage semantics
+        // norms. Exact callers of lossy encodings opt into that storage semantics
         // instead of forcing a decode-and-recompute path here.
         if input_ref.is::<ExactScalarFn<L2Denorm>>() {
             let (_, norms) = extract_l2_denorm_children(&input_ref);
@@ -254,6 +256,7 @@ mod tests {
     use rstest::rstest;
     use vortex_array::ArrayPlugin;
     use vortex_array::ArrayRef;
+    use vortex_array::EmptyMetadata;
     use vortex_array::IntoArray;
     use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::Constant;
@@ -266,7 +269,6 @@ mod tests {
     use vortex_array::dtype::Nullability;
     use vortex_array::dtype::PType;
     use vortex_array::dtype::extension::ExtDType;
-    use vortex_array::extension::EmptyMetadata;
     use vortex_array::scalar::Scalar;
     use vortex_array::validity::Validity;
     use vortex_error::VortexResult;
@@ -280,9 +282,9 @@ mod tests {
     use crate::utils::test_helpers::vector_array;
 
     /// Evaluates L2 norm on a tensor/vector array and returns the result as `Vec<f64>`.
-    fn eval_l2_norm(input: ArrayRef, len: usize) -> VortexResult<Vec<f64>> {
+    fn eval_l2_norm(input: ArrayRef) -> VortexResult<Vec<f64>> {
         let scalar_fn = L2Norm::new().erased();
-        let result = ScalarFnArray::try_new(scalar_fn, vec![input], len)?;
+        let result = ScalarFnArray::try_new(scalar_fn, vec![input])?;
         let mut ctx = SESSION.create_execution_ctx();
         let prim: PrimitiveArray = result.into_array().execute(&mut ctx)?;
         Ok(prim.as_slice::<f64>().to_vec())
@@ -299,7 +301,7 @@ mod tests {
         #[case] expected: &[f64],
     ) -> VortexResult<()> {
         let arr = tensor_array(shape, elements)?;
-        assert_close(&eval_l2_norm(arr, 1)?, expected);
+        assert_close(&eval_l2_norm(arr)?, expected);
         Ok(())
     }
 
@@ -313,7 +315,7 @@ mod tests {
                 1.0, 1.0, 1.0, // norm = sqrt(3)
             ],
         )?;
-        assert_close(&eval_l2_norm(arr, 3)?, &[5.0, 0.0, 3.0_f64.sqrt()]);
+        assert_close(&eval_l2_norm(arr)?, &[5.0, 0.0, 3.0_f64.sqrt()]);
         Ok(())
     }
 
@@ -326,7 +328,7 @@ mod tests {
                 3.0, 4.0, 0.0, // norm = 5.0
             ],
         )?;
-        assert_close(&eval_l2_norm(arr, 2)?, &[1.0, 5.0]);
+        assert_close(&eval_l2_norm(arr)?, &[1.0, 5.0]);
         Ok(())
     }
 
@@ -337,7 +339,7 @@ mod tests {
         let arr = MaskedArray::try_new(arr, Validity::from_iter([true, false]))?.into_array();
 
         let scalar_fn = L2Norm::new().erased();
-        let result = ScalarFnArray::try_new(scalar_fn, vec![arr], 2)?;
+        let result = ScalarFnArray::try_new(scalar_fn, vec![arr])?;
         let mut ctx = SESSION.create_execution_ctx();
         let prim: PrimitiveArray = result.into_array().execute(&mut ctx)?;
 
@@ -357,7 +359,7 @@ mod tests {
         let input = literal_vector_array(&[3.0f64, 4.0], 4);
 
         let scalar_fn = L2Norm::new().erased();
-        let result = ScalarFnArray::try_new(scalar_fn, vec![input], 4)?.into_array();
+        let result = ScalarFnArray::try_new(scalar_fn, vec![input])?.into_array();
         let mut ctx = SESSION.create_execution_ctx();
         let output = result.execute_until::<Constant>(&mut ctx)?;
 
@@ -388,7 +390,7 @@ mod tests {
         let input = ConstantArray::new(null_scalar, 3).into_array();
 
         let scalar_fn = L2Norm::new().erased();
-        let result = ScalarFnArray::try_new(scalar_fn, vec![input], 3)?.into_array();
+        let result = ScalarFnArray::try_new(scalar_fn, vec![input])?.into_array();
         let mut ctx = SESSION.create_execution_ctx();
         let output = result.execute_until::<Constant>(&mut ctx)?;
 
@@ -405,10 +407,10 @@ mod tests {
     }
 
     #[rstest]
-    #[case::fixed_shape_tensor(l2_norm_tensor_child(), 2)]
-    #[case::vector(l2_norm_vector_child(), 2)]
-    fn serde_round_trip(#[case] child: ArrayRef, #[case] len: usize) -> VortexResult<()> {
-        let original = L2Norm::try_new_array(child.clone(), len)?.into_array();
+    #[case::fixed_shape_tensor(l2_norm_tensor_child())]
+    #[case::vector(l2_norm_vector_child())]
+    fn serde_round_trip(#[case] child: ArrayRef) -> VortexResult<()> {
+        let original = L2Norm::try_new_array(child.clone())?.into_array();
 
         let plugin = ScalarFnArrayPlugin::new(L2Norm);
         let metadata = plugin
diff --git a/vortex-tensor/src/scalar_fns/mod.rs b/vortex-tensor/src/scalar_fns/mod.rs
index 1d1a362c8af..9acf59bda01 100644
--- a/vortex-tensor/src/scalar_fns/mod.rs
+++ b/vortex-tensor/src/scalar_fns/mod.rs
@@ -7,4 +7,3 @@ pub mod cosine_similarity;
 pub mod inner_product;
 pub mod l2_denorm;
 pub mod l2_norm;
-pub mod sorf_transform;
diff --git a/vortex-tensor/src/scalar_fns/sorf_transform/mod.rs b/vortex-tensor/src/scalar_fns/sorf_transform/mod.rs
deleted file mode 100644
index 26d38e87a1e..00000000000
--- a/vortex-tensor/src/scalar_fns/sorf_transform/mod.rs
+++ /dev/null
@@ -1,146 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! SORF inverse transform scalar function.
-//!
-//! SORF (Structured Orthogonal Random Features, [Yu et al. 2016][sorf-paper]) is a fast structured
-//! approximation to a random orthogonal matrix. It composes random sign diagonals with the
-//! Walsh-Hadamard transform to achieve O(d log d) matrix-vector products instead of the O(d^2) cost
-//! of a dense orthogonal matrix.
-//!
-//! This module wraps a [`Vector`] extension array whose dimension is the padded SORF dimension
-//! (e.g. a `Vector` wrapping `FSL(Dict(codes, centroids))`) and applies the inverse SORF transform
-//! at execution time, producing a [`Vector`] extension array with the original (pre-padding)
-//! dimensionality.
-//!
-//! The transform parameters are stored as a deterministic seed in [`SorfOptions`], so the
-//! [`SorfMatrix`] is reconstructed cheaply at decode time. Sign diagonals are defined by Vortex's
-//! frozen local SplitMix64 stream contract rather than by an external RNG crate.
-//!
-//! # Input element type: `f32` only (TODO(connor): for now...)
-//!
-//! The child [`Vector`] **must** have `f32` storage elements. This is a hard constraint that is
-//! enforced by `SorfTransform`'s `return_dtype` check. Callers with `f16` or `f64` source data need
-//! to cast to `f32` before wrapping in a [`Vector`] and handing it to SorfTransform.
-//!
-//! The reason for this constraint is that TurboQuant (the only production caller today) stores its
-//! dictionary centroids as `f32`, and the SORF transform itself operates internally in `f32`.
-//!
-//! Supporting other float storage types would require an implicit up-/down-cast that we do not yet
-//! want to bake into SorfTransform. This restriction is intentional and may be relaxed in the
-//! future, but today it is load-bearing.
-//!
-//! # Output element type
-//!
-//! The output [`Vector`]'s element type is whatever [`SorfOptions::element_ptype`] is set to. It
-//! does **not** have to match the child's `f32` storage: we apply an explicit `f32 -> T` cast
-//! while materializing the output. This lets SorfTransform hand its result directly to a
-//! downstream consumer (e.g. [`L2Denorm`](crate::scalar_fns::l2_denorm::L2Denorm)) whose
-//! element-type expectation may differ from the `f32` the transform operated on internally.
-//!
-//! [sorf-paper]: https://proceedings.neurips.cc/paper_files/paper/2016/file/53adaf494dc89ef7196d73636eb2451b-Paper.pdf
-//! [`Vector`]: crate::vector::Vector
-
-use std::fmt;
-use std::fmt::Formatter;
-
-use vortex_array::ArrayRef;
-use vortex_array::arrays::ScalarFnArray;
-use vortex_array::dtype::PType;
-use vortex_array::scalar_fn::TypedScalarFnInstance;
-use vortex_error::VortexResult;
-use vortex_error::vortex_ensure;
-
-mod rotation;
-mod splitmix64;
-pub use rotation::SorfMatrix;
-
-mod vtable;
-
-/// Inverse SORF orthogonal transform scalar function.
-///
-/// Takes a [`Vector`](crate::vector::Vector) extension child at the padded dimension with `f32`
-/// storage, applies the inverse structured Walsh-Hadamard orthogonal transform, truncates to the
-/// original (pre-padding) dimension, casts element-wise to [`SorfOptions::element_ptype`], and
-/// wraps the result in a new [`Vector`](crate::vector::Vector) extension array.
-///
-/// See the [module-level docs](crate::scalar_fns::sorf_transform) for the rationale behind the
-/// `f32`-only input constraint.
-#[derive(Clone)]
-pub struct SorfTransform;
-
-/// Options for the SORF inverse transform scalar function.
-///
-/// Stored in the [`ScalarFnArray`] and used to deterministically reconstruct the
-/// [`SorfMatrix`] at decode time.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct SorfOptions {
-    /// Seed used to generate the structured sign diagonals via Vortex's frozen SplitMix64 stream.
-    pub seed: u64,
-    /// Number of sign-diagonal + WHT rounds in the structured orthogonal transform.
-    pub num_rounds: u8,
-    /// Original vector dimension (before power-of-2 padding). The output
-    /// [`Vector`](crate::vector::Vector) has this dimension.
-    pub dimensions: u32,
-    /// Element type of the output [`Vector`](crate::vector::Vector). The child input must always
-    /// be `f32`, but the output can be any float type (`F16`, `F32`, `F64`); the final
-    /// `f32 -> element_ptype` cast happens while building the output.
-    pub element_ptype: PType,
-}
-
-impl SorfTransform {
-    /// Creates a new [`TypedScalarFnInstance`] wrapping the SORF inverse transform with the given options.
-    pub fn new(options: &SorfOptions) -> TypedScalarFnInstance<SorfTransform> {
-        TypedScalarFnInstance::new(SorfTransform, options.clone())
-    }
-
-    /// Constructs a validated [`ScalarFnArray`] that lazily applies the inverse SORF transform.
-    ///
-    /// The `child` must be a [`Vector`] extension array (or an array that executes to one) with:
-    ///
-    /// - dimension equal to `padded_dim` (i.e. `options.dimension.next_power_of_two()`), and
-    /// - `f32` storage elements. This is a hard requirement today; see the
-    ///   [module-level docs](crate::scalar_fns::sorf_transform) for the rationale.
-    ///
-    /// The output [`Vector`] has dimension `options.dimension` and element type
-    /// `options.element_ptype`.
-    ///
-    /// [`Vector`]: crate::vector::Vector
-    pub fn try_new_array(
-        options: &SorfOptions,
-        child: ArrayRef,
-        len: usize,
-    ) -> VortexResult<ScalarFnArray> {
-        validate_sorf_options(options)?;
-
-        ScalarFnArray::try_new(SorfTransform::new(options).erased(), vec![child], len)
-    }
-}
-
-/// Checks that the SORF configuration is valid.
-pub(crate) fn validate_sorf_options(options: &SorfOptions) -> VortexResult<()> {
-    vortex_ensure!(
-        options.num_rounds >= 1,
-        "SorfTransform num_rounds must be >= 1, got {}",
-        options.num_rounds
-    );
-    vortex_ensure!(
-        options.element_ptype.is_float(),
-        "SorfTransform element_ptype must be a float type, got {}",
-        options.element_ptype
-    );
-    Ok(())
-}
-
-impl fmt::Display for SorfOptions {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "SorfOptions(seed={}, rounds={}, dim={}, ptype={})",
-            self.seed, self.num_rounds, self.dimensions, self.element_ptype
-        )
-    }
-}
-
-#[cfg(test)]
-mod tests;
diff --git a/vortex-tensor/src/scalar_fns/sorf_transform/rotation.rs b/vortex-tensor/src/scalar_fns/sorf_transform/rotation.rs
deleted file mode 100644
index b416eb4a7e6..00000000000
--- a/vortex-tensor/src/scalar_fns/sorf_transform/rotation.rs
+++ /dev/null
@@ -1,559 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! SORF (Structured Orthogonal Random Features) orthogonal transform.
-//!
-//! Implements the SORF construction from [Yu et al. 2016][sorf-paper]: a fast structured
-//! approximation to a random orthogonal matrix using random sign diagonals interleaved with the
-//! Fast Walsh-Hadamard Transform (FWHT).
-//!
-//! For `k` rounds, the transform is `norm * H * D_k * ... * H * D_1 * x`, where `D_1` is the
-//! first sign diagonal applied. The number of rounds is configurable (typically 3). Each round
-//! applies a random sign diagonal `D_i` and then the Hadamard matrix `H`, giving O(d log d) cost
-//! per matrix-vector product instead of the O(d^2) cost of a dense orthogonal matrix.
-//!
-//! Vortex defines those sign diagonals using a frozen local SplitMix64 stream rather than an
-//! external RNG crate. The contract is:
-//!
-//! - state is a single `u64` seed,
-//! - each `next_u64()` call uses the SplitMix64 reference algorithm with wrapping `u64`
-//!   arithmetic,
-//! - signs are generated in round-major, block-major order,
-//! - each generated `u64` contributes 64 signs in least-significant-bit-first order,
-//! - bit `1` means `+1` and bit `0` means `-1`.
-//!
-//! This makes SORF sign generation stable as a Vortex format contract even if external RNG
-//! implementations change.
-//!
-//! [sorf-paper]: https://proceedings.neurips.cc/paper_files/paper/2016/file/53adaf494dc89ef7196d73636eb2451b-Paper.pdf
-//!
-//! The FWHT exploits the Kronecker product structure of the Hadamard matrix (`H_n = H_2 (x) H_2
-//! (x) ... (x) H_2`, with `log2(n)` factors) to compute the matrix-vector product in O(n log n)
-//! time using only in-place 2-element butterfly operations. No row of the full n x n Hadamard
-//! matrix is ever materialized.
-//!
-//! For dimensions that are not powers of 2, the input is zero-padded to the next power of 2 before
-//! the transform and truncated afterward.
-//!
-//! # Sign representation
-//!
-//! Signs are stored internally as `u32` XOR masks: `0x00000000` for +1 (no-op) and `0x80000000` for
-//! -1 (flip IEEE 754 sign bit). The sign application function uses integer XOR instead of
-//! floating-point multiply, which avoids FP dependency chains and auto-vectorizes into
-//! `vpxor`/`veor`.
-
-use vortex_error::VortexResult;
-use vortex_error::vortex_ensure;
-
-use super::splitmix64::SplitMix64;
-
-/// IEEE 754 sign bit mask for f32.
-const F32_SIGN_BIT: u32 = 0x8000_0000;
-
-/// A Walsh-Hadamard-based structured orthogonal transform matrix.
-///
-/// All computation is done in f32. The sign diagonals are stored as IEEE 754 XOR masks on
-/// f32 bit patterns, and the Walsh-Hadamard butterfly operates on `&mut [f32]` slices.
-pub struct SorfMatrix {
-    /// Flat XOR masks for all `num_rounds` diagonal matrices, total length
-    /// `num_rounds * padded_dim`.
-    ///
-    /// Indexed as `round * padded_dim + i`. `0x00000000` = multiply by +1 (no-op), `0x80000000` =
-    /// multiply by -1 (flip sign bit).
-    sign_masks: Vec<u32>,
-    /// The number of sign-diagonal + WHT rounds.
-    num_rounds: usize,
-    /// The padded dimension (next power of 2 >= dimension).
-    padded_dim: usize,
-    /// Normalization factor: `padded_dim^(-num_rounds/2)`, applied once at the end.
-    norm_factor: f32,
-}
-
-impl SorfMatrix {
-    /// Create a new structured Walsh-Hadamard-based orthogonal transform from a deterministic
-    /// seed.
-    ///
-    /// The seed is expanded using Vortex's frozen local SplitMix64 stream. Signs are generated in
-    /// round-major, block-major order, with each `u64` contributing 64 sign bits in
-    /// least-significant-bit-first order.
-    pub fn try_new(seed: u64, dimensions: usize, num_rounds: usize) -> VortexResult<Self> {
-        Self::try_new_padded(dimensions.next_power_of_two(), num_rounds, seed)
-    }
-
-    /// Create a new structured Walsh-Hadamard-based orthogonal transform for a padded dimension.
-    ///
-    /// `padded_dimensions` must already be a power of two. Callers that start from an unpadded
-    /// logical dimension should call [`Self::try_new`] instead.
-    pub(crate) fn try_new_padded(
-        padded_dimensions: usize,
-        num_rounds: usize,
-        seed: u64,
-    ) -> VortexResult<Self> {
-        vortex_ensure!(num_rounds >= 1, "num_rounds must be >= 1, got {num_rounds}");
-        vortex_ensure!(
-            padded_dimensions.is_power_of_two(),
-            "padded_dimensions must be a power of two, got {padded_dimensions}"
-        );
-
-        let padded_dim = padded_dimensions;
-        let sign_masks = gen_sign_masks_from_seed(seed, padded_dim, num_rounds);
-
-        // Compute in f64 for precision, then store as f32 since the WHT operates on f32 buffers.
-        // The result is always in (0, 1] for any valid padded_dim >= 2 and num_rounds >= 1, so
-        // the f64 -> f32 cast is a precision loss only (it cannot overflow to infinity).
-        #[expect(
-            clippy::cast_possible_truncation,
-            reason = "the norm factor is in (0, 1] so the f64 -> f32 cast cannot overflow"
-        )]
-        let norm_factor = (padded_dim as f64).powf(-(num_rounds as f64) / 2.0) as f32;
-
-        Ok(Self {
-            sign_masks,
-            num_rounds,
-            padded_dim,
-            norm_factor,
-        })
-    }
-
-    /// Returns the padded dimension (next power of 2 >= dim).
-    ///
-    /// All `rotate`/`inverse_rotate` buffers must be this length.
-    pub fn padded_dim(&self) -> usize {
-        self.padded_dim
-    }
-
-    /// Apply the forward orthogonal transform: `output = R(input)`.
-    ///
-    /// Both `input` and `output` must have length [`padded_dim()`](Self::padded_dim). The caller is
-    /// responsible for zero-padding input beyond `dim` positions.
-    pub fn rotate(&self, input: &[f32], output: &mut [f32]) {
-        debug_assert_eq!(input.len(), self.padded_dim);
-        debug_assert_eq!(output.len(), self.padded_dim);
-
-        output.copy_from_slice(input);
-        self.apply_srht(output);
-    }
-
-    /// Apply the inverse orthogonal transform: `output = R⁻¹(input)`.
-    ///
-    /// Both `input` and `output` must have length `padded_dim()`.
-    pub fn inverse_rotate(&self, input: &[f32], output: &mut [f32]) {
-        debug_assert_eq!(input.len(), self.padded_dim);
-        debug_assert_eq!(output.len(), self.padded_dim);
-
-        output.copy_from_slice(input);
-        self.apply_inverse_srht(output);
-    }
-
-    /// Apply the forward structured transform: `norm · H · D_k · ... · H · D₁ · x`.
-    fn apply_srht(&self, buf: &mut [f32]) {
-        for round in 0..self.num_rounds {
-            self.apply_signs_xor(buf, round);
-            walsh_hadamard_transform(buf);
-        }
-
-        let norm = self.norm_factor;
-        buf.iter_mut().for_each(|val| *val *= norm);
-    }
-
-    /// Apply the inverse structured transform.
-    ///
-    /// Forward is: `norm · H · D_k · ... · H · D₁`.
-    /// Inverse is: `norm · D₁ · H · ... · D_k · H`.
-    fn apply_inverse_srht(&self, buf: &mut [f32]) {
-        for round in (0..self.num_rounds).rev() {
-            walsh_hadamard_transform(buf);
-            self.apply_signs_xor(buf, round);
-        }
-
-        let norm = self.norm_factor;
-        buf.iter_mut().for_each(|val| *val *= norm);
-    }
-
-    /// Apply one round's sign masks via XOR on the IEEE 754 sign bit.
-    ///
-    /// This is branchless and auto-vectorizes into `vpxor` (x86) / `veor` (ARM). Equivalent to
-    /// multiplying each element by +/-1.0, but avoids FP dependency chains.
-    fn apply_signs_xor(&self, buf: &mut [f32], round: usize) {
-        let masks = &self.sign_masks[round * self.padded_dim..][..self.padded_dim];
-        for (val, &mask) in buf.iter_mut().zip(masks.iter()) {
-            *val = f32::from_bits(val.to_bits() ^ mask);
-        }
-    }
-
-    /// Export the sign vectors as a flat `Vec<u8>` of 0/1 values in inverse application order
-    /// `[D_k | ... | D₁]`.
-    ///
-    /// Convention: `1` = positive (+1), `0` = negative (-1). The output has length
-    /// `num_rounds * padded_dim` and is suitable for bitpacking via FastLanes
-    /// `bitpack_encode(..., 1, None)`.
-    #[cfg(test)]
-    pub fn export_inverse_signs_u8(&self) -> Vec<u8> {
-        let total = self.num_rounds * self.padded_dim;
-        let mut out = Vec::with_capacity(total);
-
-        // Store in inverse order: round k-1 first, then k-2, ..., then 0.
-        for round in (0..self.num_rounds).rev() {
-            let offset = round * self.padded_dim;
-            for &mask in &self.sign_masks[offset..offset + self.padded_dim] {
-                out.push(if mask == 0 { 1u8 } else { 0u8 });
-            }
-        }
-        out
-    }
-
-    /// Reconstruct a [`SorfMatrix`] from unpacked `u8` 0/1 values.
-    ///
-    /// The input must have length `num_rounds * padded_dim` with signs in inverse application
-    /// order `[D_k | ... | D₁]` (as produced by [`export_inverse_signs_u8`]). Convention:
-    /// `1` = positive, `0` = negative.
-    ///
-    /// This is the decode-time reconstruction path: FastLanes SIMD-unpacks the stored
-    /// [`BitPackedArray`] into `&[u8]`, which is passed here.
-    #[cfg(test)]
-    pub fn from_u8_slice(
-        signs_u8: &[u8],
-        dimension: usize,
-        num_rounds: usize,
-    ) -> VortexResult<Self> {
-        vortex_ensure!(num_rounds >= 1, "num_rounds must be >= 1, got {num_rounds}");
-        let padded_dim = dimension.next_power_of_two();
-        vortex_ensure!(
-            signs_u8.len() == num_rounds * padded_dim,
-            "Expected {} sign bytes, got {}",
-            num_rounds * padded_dim,
-            signs_u8.len()
-        );
-
-        // The storage is in inverse application order: round k-1 first, then k-2, ..., 0.
-        // We reconstruct into forward order (round 0 at the start of the flat vec).
-        let mut sign_masks = vec![0u32; num_rounds * padded_dim];
-        for storage_idx in 0..num_rounds {
-            let round = num_rounds - 1 - storage_idx;
-            let src_offset = storage_idx * padded_dim;
-            let dst_offset = round * padded_dim;
-            for i in 0..padded_dim {
-                sign_masks[dst_offset + i] = if signs_u8[src_offset + i] != 0 {
-                    0u32
-                } else {
-                    F32_SIGN_BIT
-                };
-            }
-        }
-
-        // Same norm factor computation as `try_new`. See the comment there for why this cast
-        // cannot overflow.
-        #[expect(
-            clippy::cast_possible_truncation,
-            reason = "the norm factor is in (0, 1] so the f64 -> f32 cast cannot overflow"
-        )]
-        let norm_factor = (padded_dim as f64).powf(-(num_rounds as f64) / 2.0) as f32;
-
-        Ok(Self {
-            sign_masks,
-            num_rounds,
-            padded_dim,
-            norm_factor,
-        })
-    }
-}
-
-/// Generate XOR sign masks from the frozen local SplitMix64 stream.
-///
-/// Signs are produced in round-major, block-major order. For each block we call
-/// [`SplitMix64::next_u64`] exactly once and unpack its bits from least significant to most
-/// significant. Bit `1` means positive sign / `0x00000000`; bit `0` means negative sign /
-/// [`F32_SIGN_BIT`].
-fn gen_sign_masks_from_seed(seed: u64, padded_dim: usize, num_rounds: usize) -> Vec<u32> {
-    let mut rng = SplitMix64::new(seed);
-    let mut sign_masks = Vec::with_capacity(num_rounds * padded_dim);
-
-    for _round in 0..num_rounds {
-        for base_idx in (0..padded_dim).step_by(64) {
-            let word = rng.next_u64();
-            let bits_in_block = (padded_dim - base_idx).min(64);
-            sign_masks.extend((0..bits_in_block).map(|bit_idx| sign_mask_from_word(word, bit_idx)));
-        }
-    }
-
-    sign_masks
-}
-
-/// Convert one bit from a SplitMix64 output word into an XOR sign mask.
-fn sign_mask_from_word(word: u64, bit_idx: usize) -> u32 {
-    if ((word >> bit_idx) & 1) != 0 {
-        0u32
-    } else {
-        F32_SIGN_BIT
-    }
-}
-
-/// In-place Fast Walsh-Hadamard Transform (FWHT), unnormalized and iterative.
-///
-/// Input length must be a power of 2. Runs in O(n log n) via `log2(n)` stages of `n / 2`
-/// [`butterfly`] operations each. See the [module-level docs](self) for why this avoids
-/// materializing the full Hadamard matrix.
-///
-/// The chunk-based iteration gives LLVM enough structure to auto-vectorize each butterfly call
-/// into NEON/AVX SIMD instructions.
-fn walsh_hadamard_transform(buf: &mut [f32]) {
-    let len = buf.len();
-    debug_assert!(len.is_power_of_two());
-
-    let mut half = 1;
-    while half < len {
-        let stride = half * 2;
-        // Process in chunks of `stride` elements. Within each chunk,
-        // split into non-overlapping (lo, hi) halves for the butterfly.
-        for chunk in buf.chunks_exact_mut(stride) {
-            let (lo, hi) = chunk.split_at_mut(half);
-            butterfly(lo, hi);
-        }
-        half *= 2;
-    }
-}
-
-/// Butterfly: `(lo[i], hi[i]) -> (lo[i] + hi[i], lo[i] - hi[i])`.
-///
-/// This is multiplication by the 2x2 Hadamard kernel `H_2 = [[1, 1], [1, -1]]` on each element
-/// pair. Factored into a separate function so LLVM can see the slice lengths match and
-/// auto-vectorize.
-fn butterfly(lo: &mut [f32], hi: &mut [f32]) {
-    debug_assert_eq!(lo.len(), hi.len());
-    for (a, b) in lo.iter_mut().zip(hi.iter_mut()) {
-        let sum = *a + *b;
-        let diff = *a - *b;
-        *a = sum;
-        *b = diff;
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use rstest::rstest;
-    use vortex_error::VortexResult;
-
-    use super::*;
-    use crate::scalar_fns::sorf_transform::splitmix64::SplitMix64;
-
-    fn unpack_sign_bits(word: u64, count: usize) -> Vec<u8> {
-        (0..count)
-            .map(|bit_idx| u8::from(((word >> bit_idx) & 1) != 0))
-            .collect()
-    }
-
-    fn dim_to_usize(dim: u32) -> usize {
-        usize::try_from(dim).unwrap()
-    }
-
-    fn rounds_to_usize(num_rounds: u8) -> usize {
-        usize::from(num_rounds)
-    }
-
-    #[test]
-    fn deterministic_from_seed() -> VortexResult<()> {
-        let dim = dim_to_usize(64u32);
-        let num_rounds = rounds_to_usize(3u8);
-        let r1 = SorfMatrix::try_new(42u64, dim, num_rounds)?;
-        let r2 = SorfMatrix::try_new(42u64, dim, num_rounds)?;
-        let pd = r1.padded_dim();
-
-        let mut input = vec![0.0f32; pd];
-        for i in 0..dim {
-            input[i] = i as f32;
-        }
-        let mut out1 = vec![0.0f32; pd];
-        let mut out2 = vec![0.0f32; pd];
-
-        r1.rotate(&input, &mut out1);
-        r2.rotate(&input, &mut out2);
-
-        assert_eq!(out1, out2);
-        Ok(())
-    }
-
-    #[test]
-    fn export_inverse_signs_matches_golden_words() -> VortexResult<()> {
-        let dim = dim_to_usize(64u32);
-        let num_rounds = rounds_to_usize(2u8);
-        let seed = 42u64;
-        let rot = SorfMatrix::try_new(seed, dim, num_rounds)?;
-        let padded_dim = rot.padded_dim();
-        let actual = rot.export_inverse_signs_u8();
-        let mut rng = SplitMix64::new(seed);
-        let round0_word = rng.next_u64();
-        let round1_word = rng.next_u64();
-
-        let mut expected = Vec::with_capacity(num_rounds * padded_dim);
-        expected.extend(unpack_sign_bits(round1_word, padded_dim));
-        expected.extend(unpack_sign_bits(round0_word, padded_dim));
-
-        assert_eq!(actual, expected);
-        Ok(())
-    }
-
-    #[test]
-    fn one_word_generates_64_signs_lsb_first() {
-        let seed = 42u64;
-        let padded_dim = dim_to_usize(64u32);
-        let num_rounds = rounds_to_usize(1u8);
-        let masks = gen_sign_masks_from_seed(seed, padded_dim, num_rounds);
-        assert_eq!(masks.len(), padded_dim);
-
-        let mut rng = SplitMix64::new(seed);
-        let word = rng.next_u64();
-        let expected: Vec<_> = (0..padded_dim)
-            .map(|bit_idx| sign_mask_from_word(word, bit_idx))
-            .collect();
-        assert_eq!(masks, expected);
-    }
-
-    #[test]
-    fn accepts_non_power_of_two_dimensions() -> VortexResult<()> {
-        let rot = SorfMatrix::try_new(42u64, dim_to_usize(100u32), rounds_to_usize(3u8))?;
-        assert_eq!(rot.padded_dim(), 128);
-        Ok(())
-    }
-
-    #[test]
-    fn tail_block_uses_only_required_bits() {
-        let seed = 42u64;
-        let padded_dim = dim_to_usize(32u32);
-        let num_rounds = rounds_to_usize(1u8);
-        let masks = gen_sign_masks_from_seed(seed, padded_dim, num_rounds);
-        assert_eq!(masks.len(), padded_dim);
-
-        let mut rng = SplitMix64::new(seed);
-        let word = rng.next_u64();
-        let expected: Vec<_> = (0..padded_dim)
-            .map(|bit_idx| sign_mask_from_word(word, bit_idx))
-            .collect();
-        assert_eq!(masks, expected);
-    }
-
-    /// Verify roundtrip is exact to f32 precision across many dimensions and round counts,
-    /// including non-power-of-two dimensions that require padding.
-    #[rstest]
-    #[case(32u32, 3u8)]
-    #[case(64u32, 3u8)]
-    #[case(100u32, 3u8)]
-    #[case(128u32, 1u8)]
-    #[case(128u32, 2u8)]
-    #[case(128u32, 3u8)]
-    #[case(128u32, 5u8)]
-    #[case(256u32, 3u8)]
-    #[case(512u32, 3u8)]
-    #[case(768u32, 3u8)]
-    #[case(1024u32, 3u8)]
-    fn roundtrip_exact(#[case] dim: u32, #[case] num_rounds: u8) -> VortexResult<()> {
-        let dim = dim_to_usize(dim);
-        let num_rounds = rounds_to_usize(num_rounds);
-        let rot = SorfMatrix::try_new(42u64, dim, num_rounds)?;
-        let padded_dim = rot.padded_dim();
-
-        let mut input = vec![0.0f32; padded_dim];
-        for i in 0..dim {
-            input[i] = (i as f32 + 1.0) * 0.01;
-        }
-        let mut rotated = vec![0.0f32; padded_dim];
-        let mut recovered = vec![0.0f32; padded_dim];
-
-        rot.rotate(&input, &mut rotated);
-        rot.inverse_rotate(&rotated, &mut recovered);
-
-        let max_err: f32 = input
-            .iter()
-            .zip(recovered.iter())
-            .map(|(a, b)| (a - b).abs())
-            .fold(0.0f32, f32::max);
-        let max_val: f32 = input.iter().map(|x| x.abs()).fold(0.0f32, f32::max);
-        let rel_err = max_err / max_val;
-
-        // SRHT roundtrip should be exact up to f32 precision (~1e-6).
-        assert!(
-            rel_err < 1e-5,
-            "roundtrip relative error too large for dim={dim}, rounds={num_rounds}: {rel_err:.2e}"
-        );
-        Ok(())
-    }
-
-    /// Verify norm preservation across dimensions and round counts.
-    #[rstest]
-    #[case(128u32, 1u8)]
-    #[case(128u32, 3u8)]
-    #[case(128u32, 5u8)]
-    #[case(768u32, 3u8)]
-    fn preserves_norm(#[case] dim: u32, #[case] num_rounds: u8) -> VortexResult<()> {
-        let dim = dim_to_usize(dim);
-        let num_rounds = rounds_to_usize(num_rounds);
-        let rot = SorfMatrix::try_new(42u64, dim, num_rounds)?;
-        let padded_dim = rot.padded_dim();
-
-        let mut input = vec![0.0f32; padded_dim];
-        for i in 0..dim {
-            input[i] = (i as f32) * 0.01;
-        }
-        let input_norm: f32 = input.iter().map(|x| x * x).sum::<f32>().sqrt();
-
-        let mut rotated = vec![0.0f32; padded_dim];
-        rot.rotate(&input, &mut rotated);
-        let rotated_norm: f32 = rotated.iter().map(|x| x * x).sum::<f32>().sqrt();
-
-        assert!(
-            (input_norm - rotated_norm).abs() / input_norm < 1e-5,
-            "norm not preserved for dim={dim}: {} vs {} (rel err: {:.2e})",
-            input_norm,
-            rotated_norm,
-            (input_norm - rotated_norm).abs() / input_norm
-        );
-        Ok(())
-    }
-
-    /// Verify that export -> [`from_u8_slice`] produces identical transform output.
-    #[rstest]
-    #[case(64u32, 3u8)]
-    #[case(128u32, 1u8)]
-    #[case(128u32, 3u8)]
-    #[case(128u32, 5u8)]
-    #[case(768u32, 3u8)]
-    fn sign_export_import_roundtrip(#[case] dim: u32, #[case] num_rounds: u8) -> VortexResult<()> {
-        let dim = dim_to_usize(dim);
-        let num_rounds = rounds_to_usize(num_rounds);
-        let rot = SorfMatrix::try_new(42u64, dim, num_rounds)?;
-        let padded_dim = rot.padded_dim();
-
-        let signs_u8 = rot.export_inverse_signs_u8();
-        let rot2 = SorfMatrix::from_u8_slice(&signs_u8, dim, num_rounds)?;
-
-        let mut input = vec![0.0f32; padded_dim];
-        for i in 0..dim {
-            input[i] = (i as f32 + 1.0) * 0.01;
-        }
-
-        let mut out1 = vec![0.0f32; padded_dim];
-        let mut out2 = vec![0.0f32; padded_dim];
-        rot.rotate(&input, &mut out1);
-        rot2.rotate(&input, &mut out2);
-        assert_eq!(out1, out2, "Forward transform mismatch after export/import");
-
-        rot.inverse_rotate(&out1, &mut out2);
-        let mut out3 = vec![0.0f32; padded_dim];
-        rot2.inverse_rotate(&out1, &mut out3);
-        assert_eq!(out2, out3, "Inverse transform mismatch after export/import");
-
-        Ok(())
-    }
-
-    #[test]
-    fn wht_basic() {
-        // WHT of [1, 0, 0, 0] should be [1, 1, 1, 1]
-        let mut buf = vec![1.0f32, 0.0, 0.0, 0.0];
-        walsh_hadamard_transform(&mut buf);
-        assert_eq!(buf, vec![1.0, 1.0, 1.0, 1.0]);
-
-        // WHT is self-inverse (up to scaling by n)
-        walsh_hadamard_transform(&mut buf);
-        // After two WHTs: each element multiplied by n=4
-        assert_eq!(buf, vec![4.0, 0.0, 0.0, 0.0]);
-    }
-}
diff --git a/vortex-tensor/src/scalar_fns/sorf_transform/splitmix64.rs b/vortex-tensor/src/scalar_fns/sorf_transform/splitmix64.rs
deleted file mode 100644
index 23345cbcb7d..00000000000
--- a/vortex-tensor/src/scalar_fns/sorf_transform/splitmix64.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Frozen local SplitMix64 stream used to define SORF sign diagonals.
-//!
-//! This is a direct translation of the `splitmix64.c` reference implementation. The state is a
-//! single `u64`, and `next_u64()` first adds [`SPLITMIX64_INCREMENT`] with wrapping arithmetic,
-//! then applies the two reference mixing steps and final xor-shift.
-
-/// SplitMix64 additive constant from the reference implementation.
-const SPLITMIX64_INCREMENT: u64 = 0x9E37_79B9_7F4A_7C15;
-
-/// First SplitMix64 mixing multiplier from the reference implementation.
-const SPLITMIX64_MUL1: u64 = 0xBF58_476D_1CE4_E5B9;
-
-/// Second SplitMix64 mixing multiplier from the reference implementation.
-const SPLITMIX64_MUL2: u64 = 0x94D0_49BB_1331_11EB;
-
-/// Frozen local SplitMix64 stream used to define SORF sign diagonals.
-pub(crate) struct SplitMix64 {
-    state: u64,
-}
-
-impl SplitMix64 {
-    pub(crate) fn new(seed: u64) -> Self {
-        Self { state: seed }
-    }
-
-    pub(crate) fn next_u64(&mut self) -> u64 {
-        self.state = self.state.wrapping_add(SPLITMIX64_INCREMENT);
-        let mut z = self.state;
-        z = (z ^ (z >> 30)).wrapping_mul(SPLITMIX64_MUL1);
-        z = (z ^ (z >> 27)).wrapping_mul(SPLITMIX64_MUL2);
-        z ^ (z >> 31)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::SplitMix64;
-
-    const SPLITMIX64_SEED0_GOLDEN: [u64; 4] = [
-        0xE220_A839_7B1D_CDAF,
-        0x6E78_9E6A_A1B9_65F4,
-        0x06C4_5D18_8009_454F,
-        0xF88B_B8A8_724C_81EC,
-    ];
-
-    const SPLITMIX64_SEED42_GOLDEN: [u64; 4] = [
-        0xBDD7_3226_2FEB_6E95,
-        0x28EF_E333_B266_F103,
-        0x4752_6757_130F_9F52,
-        0x581C_E1FF_0E4A_E394,
-    ];
-
-    #[test]
-    fn splitmix64_seed0_matches_golden_outputs() {
-        let mut rng = SplitMix64::new(0);
-        let actual: Vec<_> = (0..SPLITMIX64_SEED0_GOLDEN.len())
-            .map(|_| rng.next_u64())
-            .collect();
-        assert_eq!(actual, SPLITMIX64_SEED0_GOLDEN);
-    }
-
-    #[test]
-    fn splitmix64_seed42_matches_golden_outputs() {
-        let mut rng = SplitMix64::new(42);
-        let actual: Vec<_> = (0..SPLITMIX64_SEED42_GOLDEN.len())
-            .map(|_| rng.next_u64())
-            .collect();
-        assert_eq!(actual, SPLITMIX64_SEED42_GOLDEN);
-    }
-}
diff --git a/vortex-tensor/src/scalar_fns/sorf_transform/tests.rs b/vortex-tensor/src/scalar_fns/sorf_transform/tests.rs
deleted file mode 100644
index 31f11bed07d..00000000000
--- a/vortex-tensor/src/scalar_fns/sorf_transform/tests.rs
+++ /dev/null
@@ -1,493 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Unit tests for the [`SorfTransform`] scalar function.
-
-#![allow(clippy::cast_possible_truncation)]
-
-use std::sync::Arc;
-
-use vortex_array::ArrayPlugin;
-use vortex_array::ArrayRef;
-use vortex_array::IntoArray;
-use vortex_array::VortexSessionExecute;
-use vortex_array::arrays::ExtensionArray;
-use vortex_array::arrays::FixedSizeListArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::dict::DictArray;
-use vortex_array::arrays::extension::ExtensionArrayExt;
-use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
-use vortex_array::arrays::scalar_fn::plugin::ScalarFnArrayPlugin;
-use vortex_array::dtype::DType;
-use vortex_array::dtype::Nullability;
-use vortex_array::dtype::PType;
-use vortex_array::dtype::extension::ExtDType;
-use vortex_array::extension::EmptyMetadata;
-use vortex_array::validity::Validity;
-use vortex_buffer::Buffer;
-use vortex_buffer::BufferMut;
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
-
-use super::SorfOptions;
-use super::SorfTransform;
-use super::rotation::SorfMatrix;
-use crate::encodings::turboquant::centroids::compute_centroid_boundaries;
-use crate::encodings::turboquant::centroids::compute_or_get_centroids;
-use crate::encodings::turboquant::centroids::find_nearest_centroid;
-use crate::tests::SESSION;
-use crate::types::vector::AnyVector;
-use crate::types::vector::Vector;
-
-/// Build a unit-normalized input vector array and forward-transform + quantize it, returning
-/// `(input_f32, Vector<padded_dim>(FSL(Dict(codes, centroids))), padded_dim)`.
-///
-/// This mimics what the TurboQuant compression pipeline does, but directly, so we can test
-/// `SorfTransform` in isolation.
-fn forward_rotate_and_quantize(
-    dim: usize,
-    num_rows: usize,
-    seed: u64,
-    num_rounds: usize,
-    bit_width: u8,
-) -> VortexResult<(Vec<f32>, ExtensionArray, usize)> {
-    // Build simple unit-normalized input vectors.
-    let mut input_f32 = vec![0.0f32; num_rows * dim];
-    for row in 0..num_rows {
-        let mut norm_sq = 0.0f32;
-        for i in 0..dim {
-            let val = ((row * dim + i) as f32 + 1.0) * 0.01;
-            input_f32[row * dim + i] = val;
-            norm_sq += val * val;
-        }
-        let norm = norm_sq.sqrt();
-        for i in 0..dim {
-            input_f32[row * dim + i] /= norm;
-        }
-    }
-
-    let padded_dim = dim.next_power_of_two();
-    let rotation = SorfMatrix::try_new_padded(padded_dim, num_rounds, seed)?;
-    let centroids = compute_or_get_centroids(padded_dim as u32, bit_width)?;
-    let boundaries = compute_centroid_boundaries(&centroids);
-
-    let mut all_indices = BufferMut::<u8>::with_capacity(num_rows * padded_dim);
-    let mut padded = vec![0.0f32; padded_dim];
-    let mut rotated = vec![0.0f32; padded_dim];
-
-    for row in 0..num_rows {
-        padded[..dim].copy_from_slice(&input_f32[row * dim..(row + 1) * dim]);
-        padded[dim..].fill(0.0);
-        rotation.rotate(&padded, &mut rotated);
-        for j in 0..padded_dim {
-            all_indices.push(find_nearest_centroid(rotated[j], &boundaries));
-        }
-    }
-
-    let codes = PrimitiveArray::new::<u8>(all_indices.freeze(), Validity::NonNullable);
-    let mut centroids_buf = BufferMut::<f32>::with_capacity(centroids.len());
-    centroids_buf.extend_from_slice(&centroids);
-    let centroids_arr = PrimitiveArray::new::<f32>(centroids_buf.freeze(), Validity::NonNullable);
-    let dict = DictArray::try_new(codes.into_array(), centroids_arr.into_array())?;
-    let fsl = FixedSizeListArray::try_new(
-        dict.into_array(),
-        padded_dim as u32,
-        Validity::NonNullable,
-        num_rows,
-    )?;
-    let padded_vector = wrap_as_vector(fsl, Validity::NonNullable)?;
-
-    Ok((input_f32, padded_vector, padded_dim))
-}
-
-/// Wrap an FSL in a Vector extension, optionally re-tagging its validity. This is used by tests
-/// that need to adjust top-level nullability of a padded vector child.
-fn wrap_as_vector(fsl: FixedSizeListArray, validity: Validity) -> VortexResult<ExtensionArray> {
-    let list_size = fsl.list_size();
-    let num_rows = fsl.len();
-    let elements = fsl.elements().clone();
-    let fsl = FixedSizeListArray::try_new(elements, list_size, validity, num_rows)?;
-    let ext_dtype = ExtDType::<Vector>::try_new(EmptyMetadata, fsl.dtype().clone())?.erased();
-    Ok(ExtensionArray::new(ext_dtype, fsl.into_array()))
-}
-
-/// Helper to build `SorfOptions` with common defaults.
-fn default_options(dim: u32, seed: u64) -> SorfOptions {
-    SorfOptions {
-        seed,
-        num_rounds: 3,
-        dimensions: dim,
-        element_ptype: PType::F32,
-    }
-}
-
-/// Execute a `SorfTransform` array and return the decoded flat f32 elements.
-fn execute_sorf(
-    options: &SorfOptions,
-    child: ExtensionArray,
-    num_rows: usize,
-) -> VortexResult<Vec<f32>> {
-    let sorf = SorfTransform::try_new_array(options, child.into_array(), num_rows)?;
-    let mut ctx = SESSION.create_execution_ctx();
-    let result: ExtensionArray = sorf.into_array().execute(&mut ctx)?;
-    let result_fsl: FixedSizeListArray = result.storage_array().clone().execute(&mut ctx)?;
-    let result_prim: PrimitiveArray = result_fsl.elements().clone().execute(&mut ctx)?;
-    Ok(result_prim.as_slice::<f32>().to_vec())
-}
-
-/// Build an empty `Vector<padded_dim>` extension array wrapping an empty FSL.
-fn empty_padded_vector(padded_dim: u32, validity: Validity) -> VortexResult<ExtensionArray> {
-    let elements = PrimitiveArray::empty::<f32>(Nullability::NonNullable);
-    let fsl = FixedSizeListArray::try_new(elements.into_array(), padded_dim, validity, 0)?;
-    let ext_dtype = ExtDType::<Vector>::try_new(EmptyMetadata, fsl.dtype().clone())?.erased();
-    Ok(ExtensionArray::new(ext_dtype, fsl.into_array()))
-}
-
-#[test]
-fn roundtrip_recovery() -> VortexResult<()> {
-    let dim = 128;
-    let num_rows = 10;
-    let seed = 42u64;
-    let (input_f32, padded_vector, _) = forward_rotate_and_quantize(dim, num_rows, seed, 3, 8)?;
-    let options = default_options(dim as u32, seed);
-    let result = execute_sorf(&options, padded_vector, num_rows)?;
-
-    assert_eq!(result.len(), num_rows * dim);
-
-    // At 8-bit quantization, the reconstruction should be very close to the input.
-    for row in 0..num_rows {
-        let orig = &input_f32[row * dim..(row + 1) * dim];
-        let recon = &result[row * dim..(row + 1) * dim];
-        let err_sq: f32 = orig
-            .iter()
-            .zip(recon)
-            .map(|(&a, &b)| (a - b) * (a - b))
-            .sum();
-        let norm_sq: f32 = orig.iter().map(|&v| v * v).sum();
-        assert!(
-            err_sq / norm_sq < 1e-3,
-            "row {row} MSE too high: {:.6}",
-            err_sq / norm_sq
-        );
-    }
-    Ok(())
-}
-
-#[test]
-fn empty_array_non_nullable() -> VortexResult<()> {
-    let dim = 128u32;
-    let padded_dim = dim.next_power_of_two();
-    let options = default_options(dim, 42);
-
-    // Build an empty Vector<padded_dim> child.
-    let child = empty_padded_vector(padded_dim, Validity::NonNullable)?;
-
-    let sorf = SorfTransform::try_new_array(&options, child.into_array(), 0)?;
-    let mut ctx = SESSION.create_execution_ctx();
-    let result: ExtensionArray = sorf.into_array().execute(&mut ctx)?;
-
-    assert_eq!(result.len(), 0);
-
-    // Output should be non-nullable.
-    let result_fsl: FixedSizeListArray = result.storage_array().clone().execute(&mut ctx)?;
-    assert!(!result_fsl.dtype().is_nullable());
-
-    Ok(())
-}
-
-#[test]
-fn empty_array_nullable() -> VortexResult<()> {
-    let dim = 128u32;
-    let padded_dim = dim.next_power_of_two();
-    let options = default_options(dim, 42);
-
-    // Build an empty but nullable Vector<padded_dim> child.
-    let child = empty_padded_vector(padded_dim, Validity::from(Nullability::Nullable))?;
-
-    let sorf = SorfTransform::try_new_array(&options, child.into_array(), 0)?;
-    let mut ctx = SESSION.create_execution_ctx();
-    let result: ExtensionArray = sorf.into_array().execute(&mut ctx)?;
-
-    assert_eq!(result.len(), 0);
-
-    // Output should be nullable (matching the child).
-    let result_fsl: FixedSizeListArray = result.storage_array().clone().execute(&mut ctx)?;
-    assert!(result_fsl.dtype().is_nullable());
-
-    Ok(())
-}
-
-#[test]
-fn nullable_validity_propagation() -> VortexResult<()> {
-    let dim = 128;
-    let num_rows = 4;
-    let seed = 42u64;
-    let (_, non_nullable_vector, padded_dim) =
-        forward_rotate_and_quantize(dim, num_rows, seed, 3, 8)?;
-
-    // Re-wrap the underlying FSL with a validity mask: rows 0 and 2 are valid, rows 1 and 3
-    // are null.
-    let validity = Validity::from_iter([true, false, true, false]);
-    let fsl_non_nullable: FixedSizeListArray = non_nullable_vector
-        .storage_array()
-        .clone()
-        .execute(&mut SESSION.create_execution_ctx())?;
-    let fsl_nullable = FixedSizeListArray::try_new(
-        fsl_non_nullable.elements().clone(),
-        padded_dim as u32,
-        validity.clone(),
-        num_rows,
-    )?;
-    let nullable_vector = wrap_as_vector(fsl_nullable, validity.clone())?;
-
-    let options = default_options(dim as u32, seed);
-    let sorf = SorfTransform::try_new_array(&options, nullable_vector.into_array(), num_rows)?;
-    let mut ctx = SESSION.create_execution_ctx();
-    let result: ExtensionArray = sorf.into_array().execute(&mut ctx)?;
-    let result_fsl: FixedSizeListArray = result.storage_array().clone().execute(&mut ctx)?;
-
-    // The output FSL validity should match the input.
-    let output_validity = result_fsl.validity()?;
-    for row in 0..num_rows {
-        assert_eq!(
-            output_validity.is_valid(row)?,
-            validity.is_valid(row)?,
-            "validity mismatch at row {row}"
-        );
-    }
-
-    Ok(())
-}
-
-#[test]
-fn dimension_truncation() -> VortexResult<()> {
-    // Use a non-power-of-2 dimension (padded 200 -> 256).
-    let dim = 200;
-    let num_rows = 3;
-    let seed = 42u64;
-    let (_, padded_vector, padded_dim) = forward_rotate_and_quantize(dim, num_rows, seed, 3, 8)?;
-
-    assert_eq!(padded_dim, 256, "200 should pad to 256");
-
-    let options = default_options(dim as u32, seed);
-    let result = execute_sorf(&options, padded_vector, num_rows)?;
-
-    // Output should have original dimension, not padded.
-    assert_eq!(result.len(), num_rows * dim);
-
-    Ok(())
-}
-
-#[test]
-fn return_dtype_is_vector_extension() -> VortexResult<()> {
-    let dim = 128u32;
-    let padded_dim = dim.next_power_of_two();
-    let options = default_options(dim, 42);
-
-    // Input must be a Vector<padded_dim> extension dtype.
-    let child_elem_dtype = DType::Primitive(PType::F32, Nullability::NonNullable);
-    let child_storage_dtype = DType::FixedSizeList(
-        Arc::new(child_elem_dtype),
-        padded_dim,
-        Nullability::NonNullable,
-    );
-    let child_ext_dtype = ExtDType::<Vector>::try_new(EmptyMetadata, child_storage_dtype)?.erased();
-    let child_dtype = DType::Extension(child_ext_dtype);
-
-    use vortex_array::scalar_fn::ScalarFnVTable;
-    let return_dtype = SorfTransform.return_dtype(&options, &[child_dtype])?;
-
-    // Should be a Vector extension type.
-    let ext = return_dtype
-        .as_extension_opt()
-        .expect("return dtype should be an extension type");
-    assert!(ext.metadata_opt::<AnyVector>().is_some());
-
-    // Inner FSL should have the original (unpadded) dimension.
-    let DType::FixedSizeList(_, inner_dim, _) = ext.storage_dtype() else {
-        panic!("expected storage dtype to be FSL");
-    };
-    assert_eq!(*inner_dim, dim);
-
-    Ok(())
-}
-
-#[test]
-fn rejects_zero_rounds_at_construction() {
-    let options = SorfOptions {
-        seed: 42,
-        num_rounds: 0,
-        dimensions: 128,
-        element_ptype: PType::F32,
-    };
-    let elements = PrimitiveArray::from_iter([0.0f32; 128]).into_array();
-    let child = FixedSizeListArray::try_new(elements, 128, Validity::NonNullable, 1)
-        .expect("test child should be valid");
-
-    let err = SorfTransform::try_new_array(&options, child.into_array(), 1)
-        .expect_err("zero rounds should be rejected at construction time");
-    assert!(err.to_string().contains("num_rounds"));
-}
-
-#[test]
-fn rejects_non_float_output_ptype_at_construction() {
-    let options = SorfOptions {
-        seed: 42,
-        num_rounds: 3,
-        dimensions: 128,
-        element_ptype: PType::U8,
-    };
-    let elements = PrimitiveArray::from_iter([0.0f32; 128]).into_array();
-    let child = FixedSizeListArray::try_new(elements, 128, Validity::NonNullable, 1)
-        .expect("test child should be valid");
-
-    let err = SorfTransform::try_new_array(&options, child.into_array(), 1)
-        .expect_err("non-float output ptypes should be rejected at construction time");
-    assert!(err.to_string().contains("element_ptype"));
-}
-
-#[test]
-fn rejects_non_vector_extension_child_at_construction() {
-    let options = default_options(128, 42);
-    // A bare FSL child (not wrapped in a Vector extension) should be rejected.
-    let elements = PrimitiveArray::from_iter([0.0f32; 128]).into_array();
-    let child = FixedSizeListArray::try_new(elements, 128, Validity::NonNullable, 1)
-        .expect("test child should be valid");
-
-    let err = SorfTransform::try_new_array(&options, child.into_array(), 1)
-        .expect_err("non-Vector-extension children should be rejected at construction time");
-    assert!(err.to_string().contains("Vector extension"));
-}
-
-#[test]
-fn rejects_wrong_padded_dimension_at_construction() {
-    // Options say dimension=128 so padded_dim should be 128. Pass a Vector<256> instead.
-    let options = default_options(128, 42);
-    let elements = PrimitiveArray::from_iter([0.0f32; 256]).into_array();
-    let fsl = FixedSizeListArray::try_new(elements, 256, Validity::NonNullable, 1)
-        .expect("test child should be valid");
-    let child = wrap_as_vector(fsl, Validity::NonNullable).expect("wrap should succeed");
-
-    let err = SorfTransform::try_new_array(&options, child.into_array(), 1)
-        .expect_err("mismatched padded dimension should be rejected at construction time");
-    assert!(err.to_string().contains("dimension"));
-}
-
-#[test]
-fn rejects_non_f32_child_storage_at_construction() {
-    // Options are valid and target f32 output. Pass a Vector<128> whose storage is f16 instead
-    // of f32 -- SorfTransform's f32-only input constraint should reject this.
-    let options = default_options(128, 42);
-    let elements = PrimitiveArray::from_iter([half::f16::from_f32(0.0); 128]).into_array();
-    let fsl = FixedSizeListArray::try_new(elements, 128, Validity::NonNullable, 1)
-        .expect("test child should be valid");
-    let child = wrap_as_vector(fsl, Validity::NonNullable).expect("wrap should succeed");
-
-    let err = SorfTransform::try_new_array(&options, child.into_array(), 1)
-        .expect_err("non-f32 Vector storage should be rejected at construction time");
-    assert!(err.to_string().contains("f32"));
-}
-
-#[test]
-fn f16_output_type() -> VortexResult<()> {
-    let dim = 128;
-    let num_rows = 3;
-    let seed = 42u64;
-    let (_, padded_vector, _) = forward_rotate_and_quantize(dim, num_rows, seed, 3, 8)?;
-
-    let options = SorfOptions {
-        seed,
-        num_rounds: 3,
-        dimensions: dim as u32,
-        element_ptype: PType::F16,
-    };
-    let sorf = SorfTransform::try_new_array(&options, padded_vector.into_array(), num_rows)?;
-    let mut ctx = SESSION.create_execution_ctx();
-    let result: ExtensionArray = sorf.into_array().execute(&mut ctx)?;
-    let result_fsl: FixedSizeListArray = result.storage_array().clone().execute(&mut ctx)?;
-    let result_prim: PrimitiveArray = result_fsl.elements().clone().execute(&mut ctx)?;
-
-    assert_eq!(result_prim.ptype(), PType::F16);
-    assert_eq!(result_prim.as_slice::<half::f16>().len(), num_rows * dim);
-
-    Ok(())
-}
-
-#[test]
-fn f64_output_type() -> VortexResult<()> {
-    let dim = 128;
-    let num_rows = 3;
-    let seed = 42u64;
-    let (_, padded_vector, _) = forward_rotate_and_quantize(dim, num_rows, seed, 3, 8)?;
-
-    let options = SorfOptions {
-        seed,
-        num_rounds: 3,
-        dimensions: dim as u32,
-        element_ptype: PType::F64,
-    };
-    let sorf = SorfTransform::try_new_array(&options, padded_vector.into_array(), num_rows)?;
-    let mut ctx = SESSION.create_execution_ctx();
-    let result: ExtensionArray = sorf.into_array().execute(&mut ctx)?;
-    let result_fsl: FixedSizeListArray = result.storage_array().clone().execute(&mut ctx)?;
-    let result_prim: PrimitiveArray = result_fsl.elements().clone().execute(&mut ctx)?;
-
-    assert_eq!(result_prim.ptype(), PType::F64);
-    assert_eq!(result_prim.as_slice::<f64>().len(), num_rows * dim);
-
-    Ok(())
-}
-
-/// Build a trivial `Vector<FSL<f32, padded_dim, validity>>` child populated with zeroes. The values
-/// are irrelevant for the serde round-trip test; only the dtype shape matters.
-fn trivial_padded_vector(padded_dim: u32, num_rows: usize, validity: Validity) -> ArrayRef {
-    let elements = PrimitiveArray::new(
-        Buffer::<f32>::zeroed(num_rows * padded_dim as usize),
-        Validity::NonNullable,
-    );
-    let fsl = FixedSizeListArray::try_new(elements.into_array(), padded_dim, validity, num_rows)
-        .vortex_expect("fsl must build");
-    let ext_dtype = ExtDType::<Vector>::try_new(EmptyMetadata, fsl.dtype().clone())
-        .vortex_expect("ext dtype must build")
-        .erased();
-    ExtensionArray::new(ext_dtype, fsl.into_array()).into_array()
-}
-
-#[rstest::rstest]
-// Non-power-of-two dimension to exercise `padded_dim = dim.next_power_of_two()`.
-#[case::power_of_two_dim(128, Validity::NonNullable)]
-#[case::non_power_of_two_dim(100, Validity::NonNullable)]
-// Nullable top-level Vector to verify child nullability is reconstructed from the parent output.
-#[case::nullable_child(100, Validity::AllValid)]
-fn serde_round_trip(#[case] dimensions: u32, #[case] validity: Validity) -> VortexResult<()> {
-    let padded_dim = dimensions.next_power_of_two();
-    let num_rows = 4;
-    let options = SorfOptions {
-        seed: 42,
-        num_rounds: 3,
-        dimensions,
-        element_ptype: PType::F32,
-    };
-    let child = trivial_padded_vector(padded_dim, num_rows, validity);
-    let original = SorfTransform::try_new_array(&options, child.clone(), num_rows)?.into_array();
-
-    let plugin = ScalarFnArrayPlugin::new(SorfTransform);
-    let metadata = plugin
-        .serialize(&original, &SESSION)?
-        .expect("SorfTransform serialize must produce metadata");
-
-    let children = vec![child];
-    let recovered = plugin.deserialize(
-        original.dtype(),
-        original.len(),
-        &metadata,
-        &[],
-        &children,
-        &SESSION,
-    )?;
-
-    assert_eq!(recovered.dtype(), original.dtype());
-    assert_eq!(recovered.len(), original.len());
-    assert_eq!(recovered.encoding_id(), original.encoding_id());
-    Ok(())
-}
diff --git a/vortex-tensor/src/scalar_fns/sorf_transform/vtable.rs b/vortex-tensor/src/scalar_fns/sorf_transform/vtable.rs
deleted file mode 100644
index 76648decae2..00000000000
--- a/vortex-tensor/src/scalar_fns/sorf_transform/vtable.rs
+++ /dev/null
@@ -1,334 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! [`ScalarFnVTable`] implementation for [`SorfTransform`].
-
-use std::sync::Arc;
-
-use num_traits::Float;
-use num_traits::FromPrimitive;
-use prost::Message;
-use vortex_array::ArrayRef;
-use vortex_array::ExecutionCtx;
-use vortex_array::IntoArray;
-use vortex_array::arrays::ExtensionArray;
-use vortex_array::arrays::FixedSizeListArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::ScalarFn as ScalarFnArrayEncoding;
-use vortex_array::arrays::extension::ExtensionArrayExt;
-use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
-use vortex_array::arrays::scalar_fn::ScalarFnArrayExt;
-use vortex_array::arrays::scalar_fn::ScalarFnArrayView;
-use vortex_array::arrays::scalar_fn::plugin::ScalarFnArrayParts;
-use vortex_array::arrays::scalar_fn::plugin::ScalarFnArrayVTable;
-use vortex_array::dtype::DType;
-use vortex_array::dtype::NativePType;
-use vortex_array::dtype::Nullability;
-use vortex_array::dtype::PType;
-use vortex_array::dtype::extension::ExtDType;
-use vortex_array::dtype::proto::dtype as pb;
-use vortex_array::expr::Expression;
-use vortex_array::extension::EmptyMetadata;
-use vortex_array::match_each_float_ptype;
-use vortex_array::scalar_fn::Arity;
-use vortex_array::scalar_fn::ChildName;
-use vortex_array::scalar_fn::ExecutionArgs;
-use vortex_array::scalar_fn::ScalarFnId;
-use vortex_array::scalar_fn::ScalarFnVTable;
-use vortex_array::serde::ArrayChildren;
-use vortex_array::validity::Validity;
-use vortex_buffer::BufferMut;
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
-use vortex_error::vortex_ensure_eq;
-use vortex_error::vortex_err;
-use vortex_session::VortexSession;
-
-use super::SorfOptions;
-use super::SorfTransform;
-use super::rotation::SorfMatrix;
-use super::validate_sorf_options;
-use crate::types::vector::AnyVector;
-use crate::types::vector::Vector;
-
-impl ScalarFnVTable for SorfTransform {
-    type Options = SorfOptions;
-
-    fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.tensor.sorf_transform")
-    }
-
-    fn arity(&self, _options: &Self::Options) -> Arity {
-        Arity::Exact(1)
-    }
-
-    fn child_name(&self, _options: &Self::Options, child_idx: usize) -> ChildName {
-        match child_idx {
-            0 => ChildName::from("rotated"),
-            _ => unreachable!("SorfTransform must have exactly one child"),
-        }
-    }
-
-    fn return_dtype(&self, options: &Self::Options, arg_dtypes: &[DType]) -> VortexResult<DType> {
-        validate_sorf_options(options)?;
-
-        let child_dtype = &arg_dtypes[0];
-        let vector_metadata = child_dtype
-            .as_extension_opt()
-            .and_then(|ext| ext.metadata_opt::<AnyVector>())
-            .ok_or_else(|| {
-                vortex_err!("SorfTransform child must be a Vector extension, got {child_dtype}")
-            })?;
-
-        let expected_padded = options.dimensions.next_power_of_two();
-        vortex_ensure_eq!(
-            vector_metadata.dimensions(),
-            expected_padded,
-            "SorfTransform child Vector must have dimension {expected_padded} (next power of two \
-             for dimension {})",
-            options.dimensions,
-        );
-
-        // For now, the child Vector storage must be f32. TurboQuant stores its centroids as f32,
-        // and the SORF transform itself operates in f32, so any other input type would require an
-        // implicit cast that we do not yet support. The output element type is independently
-        // specified via `options.element_ptype` and is built below.
-        vortex_ensure_eq!(
-            vector_metadata.element_ptype(),
-            PType::F32,
-            "SorfTransform child Vector storage must be f32 (for now), got {}",
-            vector_metadata.element_ptype(),
-        );
-
-        let output_elem_dtype = DType::Primitive(options.element_ptype, Nullability::NonNullable);
-        let storage_dtype = DType::FixedSizeList(
-            Arc::new(output_elem_dtype),
-            options.dimensions,
-            child_dtype.nullability(),
-        );
-
-        let _ = vector_metadata;
-        let ext_dtype = ExtDType::<Vector>::try_new(EmptyMetadata, storage_dtype)?.erased();
-
-        Ok(DType::Extension(ext_dtype))
-    }
-
-    fn execute(
-        &self,
-        options: &Self::Options,
-        args: &dyn ExecutionArgs,
-        ctx: &mut ExecutionCtx,
-    ) -> VortexResult<ArrayRef> {
-        let dim = options.dimensions as usize;
-        let num_rows = args.row_count();
-
-        if num_rows == 0 {
-            let child_dtype = args.get(0)?.dtype().clone();
-            let validity = Validity::from(child_dtype.nullability());
-
-            return match_each_float_ptype!(options.element_ptype, |T| {
-                let elements = PrimitiveArray::empty::<T>(Nullability::NonNullable);
-                let fsl = FixedSizeListArray::try_new(
-                    elements.into_array(),
-                    options.dimensions,
-                    validity,
-                    0,
-                )?;
-                Vector::try_new_vector_array(fsl.into_array())
-            });
-        }
-
-        // Execute the child to get the Vector extension wrapping an FSL of f32 coordinates. The
-        // `return_dtype` check guarantees the child is a `Vector<padded_dim, f32>`, so the
-        // materialized FSL elements are always f32.
-        let child_ext: ExtensionArray = args.get(0)?.execute(ctx)?;
-        let child_validity = child_ext.as_ref().validity()?;
-        let child_fsl: FixedSizeListArray = child_ext.storage_array().clone().execute(ctx)?;
-        let padded_dim =
-            usize::try_from(child_fsl.list_size()).vortex_expect("list_size fits usize");
-
-        let elements_prim: PrimitiveArray = child_fsl.elements().clone().execute(ctx)?;
-        let f32_elements = elements_prim.into_buffer::<f32>();
-
-        // Reconstruct the orthogonal transform matrix from the seed.
-        let rotation =
-            SorfMatrix::try_new_padded(padded_dim, options.num_rounds as usize, options.seed)?;
-
-        // Inverse transform each row, truncate to original dimension, cast to target type.
-        match_each_float_ptype!(options.element_ptype, |T| {
-            inverse_rotate_typed::<T>(
-                &f32_elements,
-                &rotation,
-                dim,
-                padded_dim,
-                num_rows,
-                child_validity,
-            )
-        })
-    }
-
-    fn validity(
-        &self,
-        _options: &Self::Options,
-        expression: &Expression,
-    ) -> VortexResult<Option<Expression>> {
-        Ok(Some(expression.child(0).validity()?))
-    }
-
-    fn is_null_sensitive(&self, _options: &Self::Options) -> bool {
-        false
-    }
-
-    fn is_fallible(&self, _options: &Self::Options) -> bool {
-        false
-    }
-}
-
-/// Metadata for a serialized [`SorfTransform`] array.
-///
-/// Stores the full [`SorfOptions`] inline along with the child [`DType`]. Older metadata omitted
-/// this field; deserialization derives the legacy plain-`Vector` child dtype from the parent dtype
-/// in that case.
-#[derive(Clone, prost::Message)]
-pub(super) struct SorfTransformMetadata {
-    #[prost(uint64, tag = "1")]
-    seed: u64,
-    /// Rust `u8` widened to `u32` for protobuf (no `u8` on the wire).
-    #[prost(uint32, tag = "2")]
-    num_rounds: u32,
-    #[prost(uint32, tag = "3")]
-    dimension: u32,
-    #[prost(enumeration = "PType", tag = "4")]
-    element_ptype: i32,
-    #[prost(message, optional, tag = "5")]
-    child_dtype: Option<pb::DType>,
-}
-
-impl ScalarFnArrayVTable for SorfTransform {
-    fn serialize(
-        &self,
-        view: &ScalarFnArrayView<Self>,
-        _session: &VortexSession,
-    ) -> VortexResult<Option<Vec<u8>>> {
-        let scalar_fn_array = view.as_::<ScalarFnArrayEncoding>();
-        let child_dtype = Some(scalar_fn_array.child_at(0).dtype().try_into()?);
-        let metadata = SorfTransformMetadata {
-            child_dtype,
-            ..SorfTransformMetadata::from(view.options)
-        };
-        Ok(Some(metadata.encode_to_vec()))
-    }
-
-    fn deserialize(
-        &self,
-        dtype: &DType,
-        len: usize,
-        metadata: &[u8],
-        children: &dyn ArrayChildren,
-        session: &VortexSession,
-    ) -> VortexResult<ScalarFnArrayParts<Self>> {
-        let metadata = SorfTransformMetadata::decode(metadata)
-            .map_err(|e| vortex_err!("Failed to decode SorfTransformMetadata: {e}"))?;
-        let options = metadata.to_options()?;
-
-        // `return_dtype` sets the output FSL's nullability to the child's nullability (see
-        // `return_dtype` above), so we read the child nullability back from the parent dtype.
-        let child_nullability = dtype
-            .as_extension_opt()
-            .ok_or_else(|| {
-                vortex_err!("SorfTransform parent dtype must be a Vector extension, got {dtype}")
-            })?
-            .storage_dtype()
-            .nullability();
-        let padded_dim = options.dimensions.next_power_of_two();
-        let child_storage = DType::FixedSizeList(
-            Arc::new(DType::Primitive(PType::F32, Nullability::NonNullable)),
-            padded_dim,
-            child_nullability,
-        );
-        let child_dtype = match metadata.child_dtype.as_ref() {
-            Some(dtype) => DType::from_proto(dtype, session)?,
-            None => {
-                let child_ext = ExtDType::<Vector>::try_new(EmptyMetadata, child_storage)?.erased();
-                DType::Extension(child_ext)
-            }
-        };
-        let child = children.get(0, &child_dtype, len)?;
-
-        Ok(ScalarFnArrayParts {
-            options,
-            children: vec![child],
-        })
-    }
-}
-
-/// Convert an f32 value to a float type `T`.
-///
-/// `FromPrimitive::from_f32` is infallible for all Vortex float types: f16 saturates via the
-/// inherent `f16::from_f32()`, f32 is identity, f64 is lossless widening.
-fn float_from_f32<T: Float + FromPrimitive>(v: f32) -> T {
-    FromPrimitive::from_f32(v).vortex_expect("f32-to-float conversion is infallible")
-}
-
-/// Apply the inverse SORF transform on f32 data, truncate to the original dimension, cast each
-/// element to `T`, and build a plain [`Vector`](crate::vector::Vector) extension array.
-fn inverse_rotate_typed<T: NativePType + Float + FromPrimitive>(
-    f32_elements: &[f32],
-    rotation: &SorfMatrix,
-    dim: usize,
-    padded_dim: usize,
-    num_rows: usize,
-    validity: Validity,
-) -> VortexResult<ArrayRef> {
-    let dim_u32 = u32::try_from(dim).vortex_expect("dimension fits u32");
-    let mut output = BufferMut::<T>::with_capacity(num_rows * dim);
-    let mut unrotated = vec![0.0f32; padded_dim];
-
-    for row in 0..num_rows {
-        let row_data = &f32_elements[row * padded_dim..(row + 1) * padded_dim];
-
-        rotation.inverse_rotate(row_data, &mut unrotated);
-
-        for idx in 0..dim {
-            // SAFETY: We allocated enough memory above.
-            unsafe { output.push_unchecked(float_from_f32::<T>(unrotated[idx])) };
-        }
-    }
-
-    let elements = PrimitiveArray::new::<T>(output.freeze(), Validity::NonNullable);
-    let fsl = FixedSizeListArray::try_new(elements.into_array(), dim_u32, validity, num_rows)?;
-    Vector::try_new_vector_array(fsl.into_array())
-}
-
-impl From<&SorfOptions> for SorfTransformMetadata {
-    fn from(options: &SorfOptions) -> Self {
-        Self {
-            seed: options.seed,
-            num_rounds: u32::from(options.num_rounds),
-            dimension: options.dimensions,
-            element_ptype: options.element_ptype as i32,
-            child_dtype: None,
-        }
-    }
-}
-
-impl SorfTransformMetadata {
-    /// Rebuild the [`SorfOptions`] this metadata was serialized from, validating that the wire
-    /// values are in range.
-    fn to_options(&self) -> VortexResult<SorfOptions> {
-        let num_rounds = u8::try_from(self.num_rounds).map_err(|_| {
-            vortex_err!(
-                "SorfTransform num_rounds {} does not fit in u8",
-                self.num_rounds
-            )
-        })?;
-        let options = SorfOptions {
-            seed: self.seed,
-            num_rounds,
-            dimensions: self.dimension,
-            element_ptype: self.element_ptype(),
-        };
-        validate_sorf_options(&options)?;
-        Ok(options)
-    }
-}
diff --git a/vortex-tensor/src/types/fixed_shape_tensor/matcher.rs b/vortex-tensor/src/types/fixed_shape_tensor/matcher.rs
index 2cd7d7c8e4c..e4e460c21a2 100644
--- a/vortex-tensor/src/types/fixed_shape_tensor/matcher.rs
+++ b/vortex-tensor/src/types/fixed_shape_tensor/matcher.rs
@@ -90,11 +90,11 @@ impl FixedShapeTensorMatcherMetadata<'_> {
 mod tests {
     use std::sync::Arc;
 
+    use vortex_array::EmptyMetadata;
     use vortex_array::dtype::DType;
     use vortex_array::dtype::Nullability;
     use vortex_array::dtype::PType;
     use vortex_array::dtype::extension::ExtDType;
-    use vortex_array::extension::EmptyMetadata;
     use vortex_error::VortexResult;
 
     use super::*;
diff --git a/vortex-tensor/src/types/vector/arrow.rs b/vortex-tensor/src/types/vector/arrow.rs
index 85690ea0cd5..9a148839f3d 100644
--- a/vortex-tensor/src/types/vector/arrow.rs
+++ b/vortex-tensor/src/types/vector/arrow.rs
@@ -15,6 +15,7 @@ use arrow_schema::DataType;
 use arrow_schema::Field;
 use arrow_schema::extension::EXTENSION_TYPE_NAME_KEY;
 use vortex_array::ArrayRef;
+use vortex_array::EmptyMetadata;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
 use vortex_array::arrays::ExtensionArray;
@@ -30,7 +31,6 @@ use vortex_array::dtype::DType;
 use vortex_array::dtype::arrow::FromArrowType;
 use vortex_array::dtype::extension::ExtDType;
 use vortex_array::dtype::extension::ExtVTable;
-use vortex_array::extension::EmptyMetadata;
 use vortex_error::VortexResult;
 use vortex_session::registry::CachedId;
 use vortex_session::registry::Id;
@@ -174,6 +174,7 @@ mod tests {
     use arrow_array::Float32Array;
     use arrow_array::Int32Array;
     use arrow_schema::Field;
+    use vortex_array::EmptyMetadata;
     use vortex_array::IntoArray;
     use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::FixedSizeListArray;
@@ -188,7 +189,6 @@ mod tests {
     use vortex_array::dtype::PType;
     use vortex_array::dtype::StructFields;
     use vortex_array::dtype::extension::ExtDType;
-    use vortex_array::extension::EmptyMetadata;
     use vortex_array::validity::Validity;
     use vortex_buffer::buffer;
 
diff --git a/vortex-tensor/src/types/vector/matcher.rs b/vortex-tensor/src/types/vector/matcher.rs
index b0e641ba45b..9f5b0037029 100644
--- a/vortex-tensor/src/types/vector/matcher.rs
+++ b/vortex-tensor/src/types/vector/matcher.rs
@@ -93,11 +93,11 @@ impl VectorMatcherMetadata {
 mod tests {
     use std::sync::Arc;
 
+    use vortex_array::EmptyMetadata;
     use vortex_array::dtype::DType;
     use vortex_array::dtype::Nullability;
     use vortex_array::dtype::PType;
     use vortex_array::dtype::extension::ExtDType;
-    use vortex_array::extension::EmptyMetadata;
     use vortex_error::VortexResult;
 
     use super::*;
diff --git a/vortex-tensor/src/types/vector/mod.rs b/vortex-tensor/src/types/vector/mod.rs
index 2019176d211..af424b9cc41 100644
--- a/vortex-tensor/src/types/vector/mod.rs
+++ b/vortex-tensor/src/types/vector/mod.rs
@@ -4,21 +4,20 @@
 //! Vector extension type for fixed-length float vectors (e.g., embeddings).
 
 use vortex_array::ArrayRef;
+use vortex_array::EmptyMetadata;
 use vortex_array::IntoArray;
 use vortex_array::arrays::ConstantArray;
 use vortex_array::arrays::ExtensionArray;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::NativePType;
 use vortex_array::dtype::Nullability;
-use vortex_array::extension::EmptyMetadata;
 use vortex_array::scalar::PValue;
 use vortex_array::scalar::Scalar;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 
-/// Validates that `storage` is a valid storage dtype for a [`Vector`] or
-/// [`NormalizedVector`](crate::normalized_vector::NormalizedVector) extension type.
+/// Validates that `storage` is a valid storage dtype for a [`Vector`].
 ///
 /// The storage must be a `FixedSizeList<float, dim, nullability>` with non-nullable float
 /// elements. The outer nullability is not constrained.
diff --git a/vortex-tensor/src/types/vector/vtable.rs b/vortex-tensor/src/types/vector/vtable.rs
index c80f17665f2..cc9f5a87de3 100644
--- a/vortex-tensor/src/types/vector/vtable.rs
+++ b/vortex-tensor/src/types/vector/vtable.rs
@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use vortex_array::EmptyMetadata;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::extension::ExtDType;
 use vortex_array::dtype::extension::ExtId;
 use vortex_array::dtype::extension::ExtVTable;
-use vortex_array::extension::EmptyMetadata;
 use vortex_array::scalar::ScalarValue;
 use vortex_error::VortexResult;
 
@@ -61,12 +61,12 @@ mod tests {
     use std::sync::Arc;
 
     use rstest::rstest;
+    use vortex_array::EmptyMetadata;
     use vortex_array::dtype::DType;
     use vortex_array::dtype::Nullability;
     use vortex_array::dtype::PType;
     use vortex_array::dtype::extension::ExtDType;
     use vortex_array::dtype::extension::ExtVTable;
-    use vortex_array::extension::EmptyMetadata;
     use vortex_error::VortexResult;
 
     use crate::types::vector::Vector;
diff --git a/vortex-tensor/src/utils.rs b/vortex-tensor/src/utils.rs
index e6d2cce453b..841cd4329c1 100644
--- a/vortex-tensor/src/utils.rs
+++ b/vortex-tensor/src/utils.rs
@@ -21,10 +21,8 @@ use vortex_array::dtype::NativePType;
 use vortex_array::dtype::PType;
 use vortex_array::dtype::proto::dtype as pb;
 use vortex_array::scalar_fn::ScalarFnVTable;
-use vortex_buffer::Buffer;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
 use vortex_session::VortexSession;
@@ -46,7 +44,7 @@ pub(crate) const SAFETY_FACTOR: usize = 10;
 ///
 /// Reference: Croci, Fasi, Higham, Mary, Mikaitis (2022). "Stochastic rounding: implementation,
 /// error analysis and applications." Royal Society Open Science, 9: 211631, §6.1 "Probabilistic
-/// error analysis." https://doi.org/10.1098/rsos.211631
+/// error analysis." <https://doi.org/10.1098/rsos.211631>
 pub fn unit_norm_tolerance(element_ptype: PType, dimensions: usize) -> f64 {
     let machine_epsilon: f64 = match element_ptype {
         PType::F64 => f64::EPSILON,
@@ -106,40 +104,6 @@ pub fn validate_binary_tensor_float_inputs<'a>(
     validate_tensor_float_input(lhs)
 }
 
-/// Cast a float [`PrimitiveArray`] to a `Buffer<f32>`.
-///
-/// Several operations in this crate (SORF transform, TurboQuant quantization) work exclusively
-/// in f32. This function handles the cast from any float ptype:
-///
-/// - f16: losslessly widened to f32.
-/// - f32: zero-copy buffer extraction.
-/// - f64: truncated to f32 precision. Values outside f32 range become +/- infinity. This is
-///   acceptable because callers of this function operate in f32 and document this constraint.
-pub fn cast_to_f32(prim: PrimitiveArray) -> VortexResult<Buffer<f32>> {
-    match prim.ptype() {
-        PType::F16 => Ok(prim
-            .as_slice::<f16>()
-            .iter()
-            .map(|&v| f32::from(v))
-            .collect()),
-        PType::F32 => Ok(prim.into_buffer()),
-        PType::F64 => Ok(prim
-            .as_slice::<f64>()
-            .iter()
-            .map(|&v| {
-                #[expect(
-                    clippy::cast_possible_truncation,
-                    reason = "f64 values outside f32 range become infinity, which is acceptable \
-                              because callers operate in f32 and document this constraint"
-                )]
-                let v = v as f32;
-                v
-            })
-            .collect()),
-        other => vortex_bail!("expected float elements, got {other:?}"),
-    }
-}
-
 /// The flat primitive elements of a tensor storage array, with typed row access.
 ///
 /// This struct hides the stride detail that arises from the [`ConstantArray`] optimization: a
@@ -260,6 +224,7 @@ pub fn extract_constant_flat_row(
 /// parent's unioned output, so both are persisted.
 ///
 /// [`CosineSimilarity`]: crate::scalar_fns::cosine_similarity::CosineSimilarity
+/// [`InnerProduct`]: crate::scalar_fns::inner_product::InnerProduct
 #[derive(Clone, prost::Message)]
 pub(crate) struct BinaryTensorOpMetadata {
     #[prost(message, optional, tag = "1")]
@@ -394,7 +359,7 @@ pub mod test_helpers {
         elements: &[T],
         len: usize,
     ) -> ArrayRef {
-        use vortex_array::extension::EmptyMetadata;
+        use vortex_array::EmptyMetadata;
         let ext_scalar = Scalar::extension::<Vector>(EmptyMetadata, fsl_scalar(elements));
         ConstantArray::new(ext_scalar, len).into_array()
     }
@@ -408,11 +373,10 @@ pub mod test_helpers {
         norms: &[T],
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<ArrayRef> {
-        let len = norms.len();
         let normalized = tensor_array(shape, normalized_elements)?;
         let norms =
             PrimitiveArray::new(Buffer::copy_from(norms), Validity::NonNullable).into_array();
-        Ok(L2Denorm::try_new_array(normalized, norms, len, ctx)?.into_array())
+        Ok(L2Denorm::try_new_array(normalized, norms, ctx)?.into_array())
     }
 
     /// Asserts that each element in `actual` is within `1e-10` of the corresponding `expected`
diff --git a/vortex-tensor/src/vector_search.rs b/vortex-tensor/src/vector_search.rs
index 2a036accdfe..ad3b96d1bff 100644
--- a/vortex-tensor/src/vector_search.rs
+++ b/vortex-tensor/src/vector_search.rs
@@ -7,8 +7,7 @@
 //! [`build_similarity_search_tree`] broadcasts the query into the shape expected by
 //! [`CosineSimilarity`] via `Vector::constant_array` and returns a lazy
 //! `Binary(Gt, [CosineSimilarity(data, query), threshold])` expression. The caller is responsible
-//! for preparing `data` (e.g. by running it through [`turboquant_encode`]); this builder does not
-//! compress.
+//! for preparing `data` (e.g. by compressing it beforehand); this builder does not compress.
 //!
 //! Executing the tree into a [`BoolArray`] yields one boolean per row indicating whether that row's
 //! cosine similarity to the query exceeds `threshold`.
@@ -19,12 +18,10 @@
 //! use vortex_array::{ArrayRef, VortexSessionExecute};
 //! use vortex_array::arrays::BoolArray;
 //! use vortex_session::VortexSession;
-//! use vortex_tensor::encodings::turboquant::{TurboQuantConfig, turboquant_encode};
 //! use vortex_tensor::vector_search::build_similarity_search_tree;
 //!
 //! fn run(session: &VortexSession, data: ArrayRef, query: &[f32]) -> anyhow::Result<()> {
 //!     let mut ctx = session.create_execution_ctx();
-//!     let data = turboquant_encode(data, &TurboQuantConfig::default(), &mut ctx)?;
 //!     let tree = build_similarity_search_tree(data, query, 0.8)?;
 //!     let _matches: BoolArray = tree.execute(&mut ctx)?;
 //!     Ok(())
@@ -33,7 +30,6 @@
 //!
 //! [`Vector`]: crate::vector::Vector
 //! [`CosineSimilarity`]: crate::scalar_fns::cosine_similarity::CosineSimilarity
-//! [`turboquant_encode`]: crate::encodings::turboquant::turboquant_encode
 //! [`BoolArray`]: vortex_array::arrays::BoolArray
 
 use vortex_array::ArrayRef;
@@ -83,7 +79,7 @@ pub fn build_similarity_search_tree<T: NativePType + Into<PValue>>(
     let num_rows = data.len();
     let query_vec = Vector::constant_array(query, num_rows)?;
 
-    let cosine = CosineSimilarity::try_new_array(data, query_vec, num_rows)?.into_array();
+    let cosine = CosineSimilarity::try_new_array(data, query_vec)?.into_array();
 
     let threshold_scalar = Scalar::primitive(threshold, Nullability::NonNullable);
     let threshold_array = ConstantArray::new(threshold_scalar, num_rows).into_array();
@@ -99,8 +95,6 @@ mod tests {
     use vortex_error::VortexResult;
 
     use super::build_similarity_search_tree;
-    use crate::encodings::turboquant::TurboQuantConfig;
-    use crate::encodings::turboquant::turboquant_encode;
     use crate::tests::SESSION;
     use crate::utils::test_helpers::vector_array;
 
@@ -130,46 +124,4 @@ mod tests {
         assert!(bits.value(3));
         Ok(())
     }
-
-    #[test]
-    fn turboquant_roundtrip_preserves_ranking() -> VortexResult<()> {
-        // Build 6 rows of 128-dim vectors where row 0 is highly correlated with the query.
-        // TurboQuant should preserve the "row 0 is the best match" ordering.
-        const DIM: u32 = 128;
-        const NUM_ROWS: usize = 6;
-
-        let mut values = Vec::<f32>::with_capacity(NUM_ROWS * DIM as usize);
-        let query: Vec<f32> = (0..DIM as usize)
-            .map(|i| ((i as f32) * 0.017).sin())
-            .collect();
-
-        // Row 0: identical to query (cosine=1.0)
-        values.extend_from_slice(&query);
-        // Row 1: query + noise
-        for (i, q) in query.iter().enumerate() {
-            values.push(q + 0.05 * ((i as f32) * 0.03).cos());
-        }
-        // Rows 2..6: unrelated patterns
-        for row in 2..NUM_ROWS {
-            for i in 0..DIM as usize {
-                values.push(((row as f32 * 1.3 + i as f32) * 0.07).sin());
-            }
-        }
-
-        let data = vector_array(DIM, &values)?;
-        let mut ctx = SESSION.create_execution_ctx();
-        let compressed = turboquant_encode(data, &TurboQuantConfig::default(), &mut ctx)?;
-        assert_eq!(compressed.len(), NUM_ROWS);
-
-        // Build a tree with a low threshold so row 0 (cosine=1.0 exact) matches.
-        let tree = build_similarity_search_tree(compressed, &query, 0.95)?;
-        let result: BoolArray = tree.execute(&mut ctx)?;
-        let bits = result.to_bit_buffer();
-        assert_eq!(bits.len(), NUM_ROWS);
-        assert!(
-            bits.value(0),
-            "row 0 (identical to query) must match at threshold 0.95 even after TurboQuant"
-        );
-        Ok(())
-    }
 }
diff --git a/vortex-test/compat-gen/src/adapter.rs b/vortex-test/compat-gen/src/adapter.rs
index a97399dac79..bed1300b531 100644
--- a/vortex-test/compat-gen/src/adapter.rs
+++ b/vortex-test/compat-gen/src/adapter.rs
@@ -136,7 +136,12 @@ pub fn read_layout_tree(bytes: ByteBuffer) -> VortexResult<()> {
             if row_count == 0 {
                 continue;
             }
-            let reader = layout.new_reader("".into(), Arc::clone(&segment_source), &session)?;
+            let reader = layout.new_reader(
+                "".into(),
+                Arc::clone(&segment_source),
+                &session,
+                &Default::default(),
+            )?;
             let len =
                 usize::try_from(row_count).map_err(|e| vortex_err!("row count overflow: {e}"))?;
             reader
diff --git a/vortex-test/e2e-cuda/src/lib.rs b/vortex-test/e2e-cuda/src/lib.rs
index 0a8ca91f021..7fa001c9639 100644
--- a/vortex-test/e2e-cuda/src/lib.rs
+++ b/vortex-test/e2e-cuda/src/lib.rs
@@ -1,32 +1,30 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-//! This file is a simple C-compatible API that is called from the cudf-test-harness at CI time.
-//!
-//! The flow is:
-//!
-//! * test harness calls `dlopen` in this library
-//! * invokes the `export_array` function to get back the device array
-//! * pass the arrays to `cudf`'s `from_arrow_device_column`
-//! * run some operations on the loaded column view
-//! * call `array->release()` to drop the data allocated from the Rust side
-
-#![expect(clippy::unwrap_used, clippy::expect_used)]
+//! C ABI used by `cudf-test-harness` to export and validate Arrow Device data in CI.
+
+#![expect(clippy::expect_used)]
 
 use std::env;
 use std::mem;
+use std::panic;
 use std::sync::Arc;
 use std::sync::LazyLock;
 
 use arrow_array::Array;
 use arrow_array::ArrayRef as ArrowArrayRef;
 use arrow_array::Date32Array;
+use arrow_array::Decimal32Array;
+use arrow_array::Decimal64Array;
 use arrow_array::Decimal128Array;
+use arrow_array::DictionaryArray;
 use arrow_array::StringArray;
 use arrow_array::cast::AsArray;
 use arrow_array::ffi::FFI_ArrowArray;
 use arrow_array::ffi::from_ffi;
 use arrow_array::make_array;
+use arrow_array::types::Int16Type;
+use arrow_schema::DataType;
 use arrow_schema::Field;
 use arrow_schema::Fields;
 use arrow_schema::ffi::FFI_ArrowSchema;
@@ -35,16 +33,24 @@ use vortex::array::ArrayRef as VortexArrayRef;
 use vortex::array::IntoArray;
 use vortex::array::VortexSessionExecute;
 use vortex::array::arrays::DecimalArray;
+use vortex::array::arrays::DictArray as VortexDictArray;
+use vortex::array::arrays::FixedSizeListArray;
+use vortex::array::arrays::ListArray;
 use vortex::array::arrays::PrimitiveArray;
 use vortex::array::arrays::StructArray;
 use vortex::array::arrays::TemporalArray;
 use vortex::array::arrays::VarBinViewArray;
+use vortex::array::arrays::varbinview::BinaryView;
 use vortex::array::arrow::ArrowSessionExt;
 use vortex::array::session::ArraySession;
 use vortex::array::validity::Validity;
+use vortex::buffer::Buffer;
+use vortex::buffer::ByteBuffer;
+use vortex::dtype::DType;
 use vortex::dtype::DecimalDType;
 use vortex::dtype::FieldNames;
 use vortex::dtype::NativePType;
+use vortex::dtype::Nullability;
 use vortex::extension::datetime::TimeUnit;
 use vortex::io::session::RuntimeSession;
 use vortex::layout::session::LayoutSession;
@@ -94,14 +100,104 @@ fn primitive_array() -> Result<VortexArrayRef, String> {
     })
 }
 
+fn list_array() -> VortexArrayRef {
+    ListArray::try_new(
+        PrimitiveArray::from_iter([10i32, 11, 12, 13, 14]).into_array(),
+        PrimitiveArray::from_iter([0i32, 2, 2, 5, 5, 5]).into_array(),
+        Validity::from_iter([true, false, true, true, false]),
+    )
+    .expect("list array")
+    .into_array()
+}
+
+fn fixed_size_list_array() -> VortexArrayRef {
+    FixedSizeListArray::new(
+        PrimitiveArray::from_iter(20i32..30).into_array(),
+        2,
+        Validity::from_iter([true, false, true, true, false]),
+        5,
+    )
+    .into_array()
+}
+
+fn fixed_size_list_as_list_array() -> VortexArrayRef {
+    ListArray::try_new(
+        PrimitiveArray::from_iter(20i32..30).into_array(),
+        PrimitiveArray::from_iter([0i32, 2, 4, 6, 8, 10]).into_array(),
+        Validity::from_iter([true, false, true, true, false]),
+    )
+    .expect("fixed-size-list as list array")
+    .into_array()
+}
+
+fn sliced_utf8_array() -> VortexArrayRef {
+    VarBinViewArray::from_iter_nullable_str([
+        Some("skip this out-of-line value before the slice"),
+        Some("hello"),
+        Some("こんにちは"),
+        None,
+        Some("this out-of-line value remains in the slice"),
+        Some("é"),
+        Some("skip this out-of-line value after the slice"),
+    ])
+    .into_array()
+    .slice(1..6)
+    .expect("sliced utf8 array")
+}
+
+fn multi_buffer_varbinview(dtype: DType) -> VortexArrayRef {
+    let first = ByteBuffer::copy_from("first value stored out-of-line".as_bytes());
+    let second = ByteBuffer::copy_from("second value stored out-of-line".as_bytes());
+    let views = Buffer::from_iter([
+        BinaryView::make_view(b"inline", 0, 0),
+        BinaryView::make_view(&first, 0, 0),
+        BinaryView::make_view(b"", 0, 0),
+        BinaryView::make_view(&second, 1, 0),
+        BinaryView::make_view(b"short", 0, 0),
+    ]);
+
+    VarBinViewArray::try_new(
+        views,
+        Arc::from([first, second]),
+        dtype,
+        Validity::NonNullable,
+    )
+    .expect("multi-buffer VarBinViewArray")
+    .into_array()
+}
+
+fn multi_buffer_utf8_array() -> VortexArrayRef {
+    multi_buffer_varbinview(DType::Utf8(Nullability::NonNullable))
+}
+
+/// Build a small dictionary column for cuDF Arrow Device import validation.
+fn dictionary_array() -> VortexArrayRef {
+    VortexDictArray::try_new(
+        PrimitiveArray::from_option_iter([Some(0u8), Some(1), None, Some(2), Some(1)]).into_array(),
+        VarBinViewArray::from_iter_str(["apple", "banana", "cherry"]).into_array(),
+    )
+    .expect("dictionary array")
+    .into_array()
+}
+
 /// # Safety
-/// called by C++ code.
+/// `schema_ptr` and `array_ptr` must be valid writable pointers.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn export_array(
     schema_ptr: &mut FFI_ArrowSchema,
     array_ptr: &mut ArrowDeviceArray,
 ) -> i32 {
-    let mut ctx = CudaSession::create_execution_ctx(&SESSION).unwrap();
+    ffi_boundary("export_array", || export_array_inner(schema_ptr, array_ptr))
+}
+
+fn export_array_inner(schema_ptr: &mut FFI_ArrowSchema, array_ptr: &mut ArrowDeviceArray) -> i32 {
+    let mut ctx = match CudaSession::create_execution_ctx(&SESSION) {
+        Ok(ctx) => ctx,
+        Err(err) => {
+            eprintln!("error creating CUDA execution context: {err}");
+            return 1;
+        }
+    };
 
     let primitive = match primitive_array() {
         Ok(array) => array,
@@ -110,9 +206,19 @@ pub unsafe extern "C" fn export_array(
             return 1;
         }
     };
-    let decimal = DecimalArray::from_option_iter(
-        [Some(0i128), Some(1), None, Some(3), Some(4)],
-        DecimalDType::new(38, 2),
+    // cuDF supports Arrow decimal device imports through Decimal128. Decimal256 is intentionally
+    // not included here because cuDF has no DECIMAL256 type_id or Arrow interop mapping.
+    let decimal32 = DecimalArray::from_option_iter(
+        [Some(0i8), Some(1), None, Some(3), Some(4)],
+        DecimalDType::new(9, 2),
+    );
+    let decimal64 = DecimalArray::from_option_iter(
+        [Some(0i32), Some(1), None, Some(3), Some(4)],
+        DecimalDType::new(10, 2),
+    );
+    let decimal128 = DecimalArray::from_option_iter(
+        [Some(0i64), Some(1), None, Some(3), Some(4)],
+        DecimalDType::new(19, 2),
     );
     let strings = VarBinViewArray::from_iter_nullable_str([
         Some("one"),
@@ -128,12 +234,34 @@ pub unsafe extern "C" fn export_array(
     );
 
     let array = StructArray::new(
-        FieldNames::from_iter(["prims", "decimals", "strings", "dates"]),
+        FieldNames::from_iter([
+            "prims",
+            "decimal32",
+            "decimal64",
+            "decimal128",
+            "strings",
+            "sliced_utf8",
+            "multi_buffer_utf8",
+            // Arrow Binary is intentionally omitted from the cuDF harness for now: cuDF's
+            // Arrow Device import path rejects NANOARROW_TYPE_BINARY, and treating arbitrary
+            // bytes as strings would be semantically incorrect.
+            "dates",
+            "dictionary",
+            "lists",
+            "fixed_lists",
+        ]),
         vec![
             primitive,
-            decimal.into_array(),
+            decimal32.into_array(),
+            decimal64.into_array(),
+            decimal128.into_array(),
             strings.into_array(),
+            sliced_utf8_array(),
+            multi_buffer_utf8_array(),
             dates.into_array(),
+            dictionary_array(),
+            list_array(),
+            fixed_size_list_array(),
         ],
         5,
         Validity::NonNullable,
@@ -154,16 +282,38 @@ pub unsafe extern "C" fn export_array(
 }
 
 /// # Safety
-/// called by C++ code.
+/// `ffi_schema` and `ffi_array` must describe a valid Arrow C Data array.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn validate_array(
     ffi_schema: &FFI_ArrowSchema,
     ffi_array: &mut FFI_ArrowArray,
 ) -> i32 {
-    // SAFETY: the provided pointers must not be null, and must point at valid FFI Arrow types.
+    ffi_boundary("validate_array", || {
+        validate_array_inner(ffi_schema, ffi_array)
+    })
+}
+
+fn ffi_boundary(name: &str, f: impl FnOnce() -> i32) -> i32 {
+    match panic::catch_unwind(panic::AssertUnwindSafe(f)) {
+        Ok(code) => code,
+        Err(_) => {
+            eprintln!("panic in {name}");
+            1
+        }
+    }
+}
+
+fn validate_array_inner(ffi_schema: &FFI_ArrowSchema, ffi_array: &mut FFI_ArrowArray) -> i32 {
+    // SAFETY: guaranteed by the C ABI contract.
     let array_data = unsafe {
         let ffi_array = mem::replace(ffi_array, FFI_ArrowArray::empty());
-        from_ffi(ffi_array, ffi_schema).expect("from_ffi failed")
+        match from_ffi(ffi_array, ffi_schema) {
+            Ok(array_data) => array_data,
+            Err(err) => {
+                eprintln!("from_ffi failed: {err}");
+                return 1;
+            }
+        }
     };
 
     let array = make_array(array_data);
@@ -177,7 +327,14 @@ pub unsafe extern "C" fn validate_array(
             &mut SESSION.create_execution_ctx(),
         )
         .expect("expected primitive Arrow array");
-    let decimal = Decimal128Array::from_iter([Some(0i128), Some(1), None, Some(3), Some(4)])
+    let decimal32 = Decimal32Array::from_iter([Some(0i32), Some(1), None, Some(3), Some(4)])
+        // cuDF stores decimals using the maximum precision for the physical width and preserves scale.
+        .with_precision_and_scale(9, 2)
+        .expect("with_precision_and_scale");
+    let decimal64 = Decimal64Array::from_iter([Some(0i64), Some(1), None, Some(3), Some(4)])
+        .with_precision_and_scale(18, 2)
+        .expect("with_precision_and_scale");
+    let decimal128 = Decimal128Array::from_iter([Some(0i128), Some(1), None, Some(3), Some(4)])
         .with_precision_and_scale(38, 2)
         .expect("with_precision_and_scale");
     let string = StringArray::from_iter([
@@ -187,32 +344,129 @@ pub unsafe extern "C" fn validate_array(
         Some("four"),
         None,
     ]);
+    let sliced_utf8 = StringArray::from_iter([
+        Some("hello"),
+        Some("こんにちは"),
+        None,
+        Some("this out-of-line value remains in the slice"),
+        Some("é"),
+    ]);
+    let multi_buffer_utf8 = StringArray::from_iter([
+        Some("inline"),
+        Some("first value stored out-of-line"),
+        Some(""),
+        Some("second value stored out-of-line"),
+        Some("short"),
+    ]);
     let date = Date32Array::from(vec![Some(100i32), None, Some(300), Some(400), None]);
+    let dictionary = Arc::new(
+        vec![
+            Some("apple"),
+            Some("banana"),
+            None,
+            Some("cherry"),
+            Some("banana"),
+        ]
+        .into_iter()
+        .collect::<DictionaryArray<Int16Type>>(),
+    );
+    let list = SESSION
+        .arrow()
+        .execute_arrow(list_array(), None, &mut SESSION.create_execution_ctx())
+        .expect("expected list Arrow array");
+    let fixed_size_list = SESSION
+        .arrow()
+        .execute_arrow(
+            fixed_size_list_as_list_array(),
+            None,
+            &mut SESSION.create_execution_ctx(),
+        )
+        .expect("expected fixed-size-list-as-list Arrow array");
 
     let expected_fields = Fields::from_iter([
         Field::new("prims", primitive.data_type().clone(), true),
-        Field::new("decimals", decimal.data_type().clone(), true),
+        Field::new("decimal32", decimal32.data_type().clone(), true),
+        Field::new("decimal64", decimal64.data_type().clone(), true),
+        Field::new("decimal128", decimal128.data_type().clone(), true),
         Field::new("strings", string.data_type().clone(), true),
+        Field::new("sliced_utf8", sliced_utf8.data_type().clone(), true),
+        Field::new(
+            "multi_buffer_utf8",
+            multi_buffer_utf8.data_type().clone(),
+            false,
+        ),
         Field::new("dates", date.data_type().clone(), true),
+        Field::new("dictionary", dictionary.data_type().clone(), true),
+        cudf_list_field("lists"),
+        cudf_list_field("fixed_lists"),
     ]);
+    if &expected_fields != struct_array.fields() {
+        eprintln!("wrong fields for host array");
+        eprintln!("expected fields: {}", format_fields(&expected_fields));
+        eprintln!("actual fields: {}", format_fields(struct_array.fields()));
+        return 1;
+    }
 
-    assert_eq!(
-        &expected_fields,
-        struct_array.fields(),
-        "wrong fields for host array: {:?}",
-        struct_array.fields()
-    );
-
-    let expected_fields: [ArrowArrayRef; _] = [
+    let expected_arrays: [ArrowArrayRef; 9] = [
         primitive,
-        Arc::new(decimal),
+        Arc::new(decimal32),
+        Arc::new(decimal64),
+        Arc::new(decimal128),
         Arc::new(string),
+        Arc::new(sliced_utf8),
+        Arc::new(multi_buffer_utf8),
         Arc::new(date),
+        dictionary,
     ];
 
-    for (expected, actual) in expected_fields.iter().zip(struct_array.columns()) {
-        assert_eq!(expected.as_ref(), actual.as_ref());
+    for (idx, (expected, actual)) in expected_arrays
+        .iter()
+        .zip(struct_array.columns())
+        .enumerate()
+    {
+        if expected.as_ref() != actual.as_ref() {
+            eprintln!("wrong values for host column {idx}");
+            return 1;
+        }
+    }
+
+    if !list_values_eq(list.as_ref(), struct_array.column(9).as_ref()) {
+        eprintln!("wrong values for lists column");
+        return 1;
+    }
+    if !list_values_eq(fixed_size_list.as_ref(), struct_array.column(10).as_ref()) {
+        eprintln!("wrong values for fixed_lists column");
+        return 1;
     }
 
     0
 }
+
+fn cudf_list_field(name: &str) -> Field {
+    Field::new_list(name, Field::new("element", DataType::Int32, false), true)
+}
+
+fn format_fields(fields: &Fields) -> String {
+    fields
+        .iter()
+        .map(|field| {
+            format!(
+                "{}: {}{}",
+                field.name(),
+                field.data_type(),
+                if field.is_nullable() { "?" } else { "" }
+            )
+        })
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
+fn list_values_eq(expected: &dyn Array, actual: &dyn Array) -> bool {
+    let expected = expected.as_list::<i32>();
+    let actual = actual.as_list::<i32>();
+
+    expected.len() == actual.len()
+        && expected.value_offsets() == actual.value_offsets()
+        && (0..expected.len()).all(|idx| expected.is_null(idx) == actual.is_null(idx))
+        && expected.values().as_ref() == actual.values().as_ref()
+}
diff --git a/vortex-tui/src/browse/app.rs b/vortex-tui/src/browse/app.rs
index 0a7f13ab277..97e17bac205 100644
--- a/vortex-tui/src/browse/app.rs
+++ b/vortex-tui/src/browse/app.rs
@@ -360,7 +360,12 @@ impl AppState {
 
         // Load the array.
         let reader = layout
-            .new_reader("".into(), self.vxf.segment_source(), &self.session)
+            .new_reader(
+                "".into(),
+                self.vxf.segment_source(),
+                &self.session,
+                &Default::default(),
+            )
             .vortex_expect("Failed to create reader");
         let array = reader
             .projection_evaluation(
diff --git a/vortex-tui/src/browse/ui/layouts.rs b/vortex-tui/src/browse/ui/layouts.rs
index c3245446197..14c9531645c 100644
--- a/vortex-tui/src/browse/ui/layouts.rs
+++ b/vortex-tui/src/browse/ui/layouts.rs
@@ -27,6 +27,8 @@ use ratatui::widgets::Table;
 use ratatui::widgets::Widget;
 use ratatui::widgets::Wrap;
 use vortex::array::ArrayRef;
+use vortex::array::Canonical;
+use vortex::array::IntoArray;
 use vortex::array::VortexSessionExecute;
 use vortex::array::arrays::StructArray;
 use vortex::array::arrays::struct_::StructArrayExt;
@@ -161,7 +163,19 @@ fn render_array(app: &AppState, area: Rect, buf: &mut Buffer, is_stats_table: bo
 
         assert_eq!(app.cursor.dtype(), array.dtype());
 
-        let field_arrays: Vec<ArrayRef> = struct_array.unmasked_fields().to_vec();
+        // Canonicalize each field once so the per-row `execute_scalar` calls below do not
+        // re-decode the field encodings for every row.
+        let field_arrays: Vec<ArrayRef> = struct_array
+            .unmasked_fields()
+            .iter()
+            .map(|field| {
+                field
+                    .clone()
+                    .execute::<Canonical>(&mut ctx)
+                    .vortex_expect("failed to canonicalize field array")
+                    .into_array()
+            })
+            .collect();
 
         // TODO: trim the number of displayed rows and allow paging through column stats.
         let mut rows = Vec::with_capacity(array.len());
diff --git a/vortex-tui/src/browse/ui/query.rs b/vortex-tui/src/browse/ui/query.rs
index 709acf746b5..fe6a7d872e0 100644
--- a/vortex-tui/src/browse/ui/query.rs
+++ b/vortex-tui/src/browse/ui/query.rs
@@ -273,8 +273,8 @@ impl QueryState {
     /// Spawn a background task for the pending query, if any.
     ///
     /// After calling `prepare_*` methods, call this to kick off execution.
-    /// The result will arrive on [`pending_rx`] and should be applied with
-    /// [`apply_query_result`].
+    /// The result will arrive on `pending_rx` and should be applied with
+    /// [`Self::apply_query_result`].
     pub(crate) fn spawn_pending(&mut self, session: &VortexSession, file_path: &str) {
         if !self.pending_execution {
             return;
diff --git a/vortex-tui/src/segments.rs b/vortex-tui/src/segments.rs
index ac132280325..847aec65bef 100644
--- a/vortex-tui/src/segments.rs
+++ b/vortex-tui/src/segments.rs
@@ -35,7 +35,7 @@ struct ColumnInfo {
 
 #[derive(Serialize)]
 struct SegmentInfo {
-    /// Segment name (e.g., "[0]", "data", etc.)
+    /// Segment name (e.g., "\[0\]", "data", etc.)
     name: String,
     /// Row range start
     row_offset: u64,
diff --git a/vortex-tui/src/wasm.rs b/vortex-tui/src/wasm.rs
index 8b643161fe2..5fd7dd9054b 100644
--- a/vortex-tui/src/wasm.rs
+++ b/vortex-tui/src/wasm.rs
@@ -78,7 +78,12 @@ async fn load_flat_array(
     row_count: u64,
 ) -> vortex::array::ArrayRef {
     let reader = layout
-        .new_reader("".into(), segment_source.clone(), session)
+        .new_reader(
+            "".into(),
+            segment_source.clone(),
+            session,
+            &Default::default(),
+        )
         .vortex_expect("Failed to create reader");
     reader
         .projection_evaluation(
diff --git a/vortex-turboquant/benches/encode_decode.rs b/vortex-turboquant/benches/encode_decode.rs
deleted file mode 100644
index f88c37c347a..00000000000
--- a/vortex-turboquant/benches/encode_decode.rs
+++ /dev/null
@@ -1,147 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Benchmarks for `turboquant_encode` and `turboquant_decode` across different validity-mask
-//! shapes.
-//!
-//! The four mask shapes (`AllTrue`, `AllFalse`, dense `Values`, sparse `Values`) exercise the
-//! variant-specialized paths added in the mask refactor in `vector/normalize.rs`,
-//! `vector/quantize.rs`, and `scalar_fns/decode.rs`.
-
-#![expect(clippy::unwrap_used)]
-
-use std::sync::LazyLock;
-
-use divan::Bencher;
-use rand::RngExt;
-use rand::SeedableRng as _;
-use rand::rngs::StdRng;
-use vortex_array::ArrayRef;
-use vortex_array::ExecutionCtx;
-use vortex_array::IntoArray;
-use vortex_array::VortexSessionExecute;
-use vortex_array::arrays::ExtensionArray;
-use vortex_array::arrays::FixedSizeListArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::extension::EmptyMetadata;
-use vortex_array::session::ArraySession;
-use vortex_array::validity::Validity;
-use vortex_buffer::Buffer;
-use vortex_session::VortexSession;
-use vortex_tensor::vector::Vector;
-use vortex_turboquant::TQDecode;
-use vortex_turboquant::TQEncode;
-use vortex_turboquant::TurboQuantConfig;
-
-fn main() {
-    divan::main();
-}
-
-static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
-    let session = VortexSession::empty().with::<ArraySession>();
-    vortex_turboquant::initialize(&session);
-    session
-});
-
-/// Shape of the validity mask used to drive the variant-specialized paths.
-#[derive(Copy, Clone)]
-enum MaskShape {
-    AllValid,
-    AllInvalid,
-    DenseValues,
-    SparseValues,
-}
-
-impl std::fmt::Debug for MaskShape {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(match self {
-            MaskShape::AllValid => "all_valid",
-            MaskShape::AllInvalid => "all_invalid",
-            MaskShape::DenseValues => "dense_95pct",
-            MaskShape::SparseValues => "sparse_5pct",
-        })
-    }
-}
-
-impl MaskShape {
-    fn build(self, rows: usize, rng: &mut StdRng) -> Validity {
-        match self {
-            MaskShape::AllValid => Validity::NonNullable,
-            MaskShape::AllInvalid => Validity::AllInvalid,
-            MaskShape::DenseValues => Validity::from_iter((0..rows).map(|_| rng.random_bool(0.95))),
-            MaskShape::SparseValues => {
-                Validity::from_iter((0..rows).map(|_| rng.random_bool(0.05)))
-            }
-        }
-    }
-}
-
-const MASK_SHAPES: &[MaskShape] = &[
-    MaskShape::AllValid,
-    MaskShape::AllInvalid,
-    MaskShape::DenseValues,
-    MaskShape::SparseValues,
-];
-
-const ROWS: usize = 4096;
-const DIMENSIONS: u32 = 128;
-
-fn build_vector_array(shape: MaskShape) -> ArrayRef {
-    let mut rng = StdRng::seed_from_u64(0xC0FFEE);
-    let dim = DIMENSIONS as usize;
-    let values: Buffer<f32> = (0..ROWS * dim).map(|_| rng.random::<f32>()).collect();
-    let elements = PrimitiveArray::new::<f32>(values, Validity::NonNullable);
-    let validity = shape.build(ROWS, &mut rng);
-    let fsl =
-        FixedSizeListArray::try_new(elements.into_array(), DIMENSIONS, validity, ROWS).unwrap();
-
-    ExtensionArray::try_new_from_vtable(Vector, EmptyMetadata, fsl.into_array())
-        .unwrap()
-        .into_array()
-}
-
-fn encode(vec: ArrayRef, config: &TurboQuantConfig, ctx: &mut ExecutionCtx) -> ArrayRef {
-    TQEncode::try_new_array(vec, config)
-        .unwrap()
-        .into_array()
-        .execute(ctx)
-        .unwrap()
-}
-
-fn decode(encoded: ArrayRef, ctx: &mut ExecutionCtx) -> ArrayRef {
-    TQDecode::try_new_array(encoded)
-        .unwrap()
-        .into_array()
-        .execute(ctx)
-        .unwrap()
-}
-
-fn config() -> TurboQuantConfig {
-    // 4 bits, 4 SORF rounds, fixed seed: representative defaults from the test fixtures.
-    TurboQuantConfig::try_new(4, 0xDEADBEEF, 4).unwrap()
-}
-
-#[divan::bench(args = MASK_SHAPES)]
-fn turboquant_encode(bencher: Bencher, shape: &MaskShape) {
-    let shape = *shape;
-    let cfg = config();
-    bencher
-        .with_inputs(|| (build_vector_array(shape), SESSION.create_execution_ctx()))
-        .input_counter(|_| divan::counter::ItemsCount::new(ROWS))
-        .bench_values(|(arr, mut ctx)| encode(arr, &cfg, &mut ctx))
-}
-
-#[divan::bench(args = MASK_SHAPES)]
-fn turboquant_decode(bencher: Bencher, shape: &MaskShape) {
-    let shape = *shape;
-    let cfg = config();
-    bencher
-        .with_inputs(|| {
-            let arr = build_vector_array(shape);
-            let mut ctx = SESSION.create_execution_ctx();
-            let encoded = encode(arr, &cfg, &mut ctx);
-            (encoded, SESSION.create_execution_ctx())
-        })
-        .input_counter(|_| divan::counter::ItemsCount::new(ROWS))
-        .bench_values(|(encoded, mut ctx)| decode(encoded, &mut ctx))
-}
diff --git a/vortex-turboquant/src/centroids.rs b/vortex-turboquant/src/centroids.rs
deleted file mode 100644
index 2be60c0ed4e..00000000000
--- a/vortex-turboquant/src/centroids.rs
+++ /dev/null
@@ -1,361 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Max-Lloyd centroid computation for TurboQuant scalar quantizers.
-//!
-//! Pre-computes and caches optimal scalar quantizer centroids for the marginal distribution of
-//! coordinates after a random orthogonal transform of a unit-norm vector.
-//!
-//! In high dimensions, each coordinate of a randomly transformed unit vector follows a
-//! distribution proportional to `(1 - x^2)^((d-3)/2)` on `[-1, 1]`, which converges to
-//! `N(0, 1/d)`.
-//!
-//! The Max-Lloyd algorithm finds optimal quantization centroids that minimize MSE for this
-//! distribution.
-//!
-//! Centroids are not stored in TurboQuant arrays. They are deterministically derived from
-//! `(padded_dim, bit_width)` and cached process-locally.
-//!
-//! The centroid model follows the random orthogonal transform marginal used by the TurboQuant
-//! paper. This encoder applies a SORF-style structured transform instead of a dense random Gaussian
-//! or orthogonal matrix, so paper-level error bounds should not be treated as verified for this
-//! implementation without separate empirical validation.
-
-use std::sync::LazyLock;
-
-use vortex_buffer::Buffer;
-use vortex_error::VortexResult;
-use vortex_error::vortex_ensure;
-use vortex_utils::aliases::dash_map::DashMap;
-
-use crate::config::MAX_BIT_WIDTH;
-use crate::config::MIN_DIMENSION;
-
-// NB: All of these constants were chosen arbitrarily.
-
-/// The maximum iterations for Max-Lloyd algorithm when computing centroids.
-const MAX_ITERATIONS: usize = 200;
-
-/// The Max-Lloyd convergence threshold for stopping early when computing centroids.
-const CONVERGENCE_EPSILON: f64 = 1e-12;
-
-/// Number of trapezoids used for numerical integration when computing conditional expectations.
-///
-/// The trapezoidal rule evaluates the integrand at `INTEGRATION_TRAPEZOIDS + 1` points.
-const INTEGRATION_TRAPEZOIDS: usize = 1000;
-
-/// Global centroid cache keyed by (dimension, bit_width).
-static CENTROID_CACHE: LazyLock<DashMap<(u32, u8), Buffer<f32>>> = LazyLock::new(DashMap::default);
-
-/// Get or compute cached centroids for the given dimension and bit width.
-///
-/// Returns `2^bit_width` centroids sorted in ascending order, representing optimal scalar
-/// quantization levels for the coordinate distribution after a random orthogonal transform in
-/// `dimension`-dimensional space.
-pub(crate) fn compute_or_get_centroids(dimension: u32, bit_width: u8) -> VortexResult<Buffer<f32>> {
-    vortex_ensure!(
-        (1..=MAX_BIT_WIDTH).contains(&bit_width),
-        "TurboQuant bit_width must be 1-{}, got {bit_width}",
-        MAX_BIT_WIDTH
-    );
-    vortex_ensure!(
-        dimension >= MIN_DIMENSION,
-        "TurboQuant dimension must be >= {}, got {dimension}",
-        MIN_DIMENSION
-    );
-
-    if let Some(centroids) = CENTROID_CACHE.get(&(dimension, bit_width)) {
-        return Ok(centroids.clone());
-    }
-
-    let centroids = max_lloyd_centroids(dimension, bit_width);
-    CENTROID_CACHE.insert((dimension, bit_width), centroids.clone());
-
-    Ok(centroids)
-}
-
-// TODO(connor): It would potentially be more performant if this was modelled as const generic
-// parameters to functions.
-/// Half-integer exponent: represents `int_part + (if has_half { 0.5 } else { 0.0 })`.
-///
-/// The marginal distribution exponent `(d-3)/2` is always an integer (when `d` is odd) or a
-/// half-integer (when `d` is even).
-///
-/// This type makes that invariant explicit and avoids floating-point comparison in the hot path.
-#[derive(Clone, Copy, Debug)]
-struct HalfIntExponent {
-    int_part: i32,
-    has_half: bool,
-}
-
-impl HalfIntExponent {
-    /// Compute `(numerator) / 2` as a half-integer exponent.
-    ///
-    /// `numerator` is `d - 3` where `d` is the dimension (>= 2), so it can be negative.
-    fn from_numerator(numerator: i32) -> Self {
-        // Use Euclidean division to get floor division toward negative infinity.
-        let int_part = numerator.div_euclid(2);
-        let has_half = numerator.rem_euclid(2) != 0;
-        Self { int_part, has_half }
-    }
-}
-
-/// Compute optimal centroids via the Max-Lloyd (Lloyd-Max) algorithm.
-///
-/// Operates on the marginal distribution of a single coordinate of a randomly transformed unit
-/// vector in d dimensions.
-///
-/// The probability distribution function is:
-///   `f(x) = C_d * (1 - x^2)^((d-3)/2)` on `[-1, 1]`
-/// where `C_d` is the normalizing constant.
-///
-/// Centroids are seeded uniformly on `[±sqrt(bit_width) * sigma]` (where `sigma` is the standard
-/// deviation of the normal distribution that hypershere dimension values take, and specifically
-/// `sigma = 1/sqrt(dimension)`) rather than across the full `[-1, 1]`, which strands most of the
-/// centroids in the near-zero-mass tails.
-///
-/// Note that the `sqrt(bit_width)` is mostly empirically derived, we do not have a theoretical
-/// basis for choosing this other than the fact that it seems to produce good results.
-fn max_lloyd_centroids(dimension: u32, bit_width: u8) -> Buffer<f32> {
-    debug_assert!((1..=MAX_BIT_WIDTH).contains(&bit_width));
-    let num_centroids = 1usize << bit_width;
-
-    // For the marginal distribution on [-1, 1], we use the exponent (d-3)/2.
-    let exponent = HalfIntExponent::from_numerator(dimension as i32 - 3);
-
-    // The coordinate marginal concentrates around 0 with this standard deviation.
-    let sigma = 1.0 / f64::from(dimension).sqrt();
-    let init_half = (f64::from(bit_width).sqrt() * sigma).min(1.0);
-
-    // Initialize centroids uniformly on [-init_half, init_half], where the mass lives, so no cell
-    // starts in a zero-mass region and freezes.
-    let mut centroids: Vec<f64> = (0..num_centroids)
-        .map(|idx| -init_half + (2.0 * (idx as f64) + 1.0) * init_half / (num_centroids as f64))
-        .collect();
-
-    let mut boundaries: Vec<f64> = vec![0.0; num_centroids + 1];
-    for _ in 0..MAX_ITERATIONS {
-        // Compute decision boundaries (midpoints between adjacent centroids).
-        boundaries[0] = -1.0;
-        for idx in 0..num_centroids - 1 {
-            boundaries[idx + 1] = (centroids[idx] + centroids[idx + 1]) / 2.0;
-        }
-        boundaries[num_centroids] = 1.0;
-
-        // Update each centroid to the conditional mean within its Voronoi cell.
-        let mut max_change = 0.0f64;
-        for idx in 0..num_centroids {
-            let lo = boundaries[idx];
-            let hi = boundaries[idx + 1];
-            let new_centroid = mean_between_centroids(lo, hi, exponent);
-            max_change = max_change.max((new_centroid - centroids[idx]).abs());
-            centroids[idx] = new_centroid;
-        }
-
-        if max_change < CONVERGENCE_EPSILON {
-            break;
-        }
-    }
-
-    #[expect(
-        clippy::cast_possible_truncation,
-        reason = "all values are in [-1, 1] so this just loses precision"
-    )]
-    centroids.into_iter().map(|val| val as f32).collect()
-}
-
-/// Compute the conditional mean of the coordinate distribution on interval [lo, hi].
-///
-/// Returns `E[X | lo <= X <= hi]` where X has PDF proportional to `(1 - x^2)^exponent` on [-1, 1].
-///
-/// Since there is no closed form for the integrals, we compute this numerically.
-fn mean_between_centroids(lo: f64, hi: f64, exponent: HalfIntExponent) -> f64 {
-    if (hi - lo).abs() < 1e-15 {
-        return (lo + hi) / 2.0;
-    }
-
-    let dx = (hi - lo) / INTEGRATION_TRAPEZOIDS as f64;
-
-    let mut numerator = 0.0;
-    let mut denominator = 0.0;
-
-    for step in 0..=INTEGRATION_TRAPEZOIDS {
-        let x_val = lo + (step as f64) * dx;
-        let weight = pdf_unnormalized(x_val, exponent);
-
-        let trap_weight = if step == 0 || step == INTEGRATION_TRAPEZOIDS {
-            0.5
-        } else {
-            1.0
-        };
-
-        numerator += trap_weight * x_val * weight;
-        denominator += trap_weight * weight;
-    }
-
-    if denominator.abs() < 1e-30 {
-        (lo + hi) / 2.0
-    } else {
-        numerator / denominator
-    }
-}
-
-/// Unnormalized PDF of the coordinate distribution: `(1 - x^2)^exponent`.
-///
-/// Uses `powi` + `sqrt` instead of `powf` for the half-integer exponents that arise from `(d-3)/2`.
-/// This is significantly faster than the general `powf` which goes through
-/// `exp(exponent * ln(base))`.
-fn pdf_unnormalized(x_val: f64, exponent: HalfIntExponent) -> f64 {
-    let base = (1.0 - x_val * x_val).max(0.0);
-
-    if exponent.has_half {
-        // Half-integer exponent: base^(int_part) * sqrt(base).
-        base.powi(exponent.int_part) * base.sqrt()
-    } else {
-        // Integer exponent: use powi directly.
-        base.powi(exponent.int_part)
-    }
-}
-
-/// Precompute decision boundaries (midpoints between adjacent centroids).
-///
-/// For `k` centroids, returns `k-1` boundaries. A value below `boundaries[0]` maps to centroid 0, a
-/// value in `[boundaries[i-1], boundaries[i])` maps to centroid `i`, and a
-/// value `>= boundaries[k-2]` maps to centroid `k-1`.
-pub(crate) fn compute_centroid_boundaries(centroids: &[f32]) -> Vec<f32> {
-    centroids.windows(2).map(|w| (w[0] + w[1]) * 0.5).collect()
-}
-
-/// Find the index of the nearest centroid using precomputed decision boundaries.
-///
-/// `boundaries` must be the output of [`compute_centroid_boundaries`] for the corresponding
-/// centroids. Uses binary search on the midpoints, avoiding distance comparisons
-/// in the inner loop.
-#[inline]
-pub(crate) fn find_nearest_centroid(value: f32, boundaries: &[f32]) -> u8 {
-    debug_assert!(
-        boundaries.windows(2).all(|w| w[0] <= w[1]),
-        "boundaries must be sorted"
-    );
-    debug_assert!(
-        boundaries.len() <= 256, // 1 << 8
-        "too many boundaries"
-    );
-
-    #[expect(
-        clippy::cast_possible_truncation,
-        reason = "num_centroids <= 256 and partition_point will return at most 255"
-    )]
-    (boundaries.partition_point(|&b| b < value) as u8)
-}
-
-#[cfg(test)]
-mod tests {
-    use rstest::rstest;
-    use vortex_error::VortexResult;
-
-    use super::*;
-
-    #[rstest]
-    #[case(128, 1, 2)]
-    #[case(128, 2, 4)]
-    #[case(128, 3, 8)]
-    #[case(128, 4, 16)]
-    #[case(768, 2, 4)]
-    #[case(1536, 3, 8)]
-    fn centroids_have_correct_count(
-        #[case] dim: u32,
-        #[case] bits: u8,
-        #[case] expected: usize,
-    ) -> VortexResult<()> {
-        let centroids = compute_or_get_centroids(dim, bits)?;
-        assert_eq!(centroids.len(), expected);
-        Ok(())
-    }
-
-    #[rstest]
-    #[case(128, 1)]
-    #[case(128, 2)]
-    #[case(128, 3)]
-    #[case(128, 4)]
-    #[case(768, 2)]
-    fn centroids_are_sorted(#[case] dim: u32, #[case] bits: u8) -> VortexResult<()> {
-        let centroids = compute_or_get_centroids(dim, bits)?;
-        for window in centroids.windows(2) {
-            assert!(
-                window[0] < window[1],
-                "centroids not sorted: {:?}",
-                centroids
-            );
-        }
-        Ok(())
-    }
-
-    #[rstest]
-    #[case(128, 1)]
-    #[case(128, 2)]
-    #[case(256, 2)]
-    #[case(768, 2)]
-    fn centroids_are_symmetric(#[case] dim: u32, #[case] bits: u8) -> VortexResult<()> {
-        let centroids = compute_or_get_centroids(dim, bits)?;
-        let count = centroids.len();
-        for idx in 0..count / 2 {
-            let diff = (centroids[idx] + centroids[count - 1 - idx]).abs();
-            assert!(
-                diff < 1e-5,
-                "centroids not symmetric: c[{idx}]={}, c[{}]={}",
-                centroids[idx],
-                count - 1 - idx,
-                centroids[count - 1 - idx]
-            );
-        }
-        Ok(())
-    }
-
-    #[rstest]
-    #[case(128, 1)]
-    #[case(128, 4)]
-    fn centroids_within_bounds(#[case] dim: u32, #[case] bits: u8) -> VortexResult<()> {
-        let centroids = compute_or_get_centroids(dim, bits)?;
-        for &val in centroids.iter() {
-            assert!(
-                (-1.0..=1.0).contains(&val),
-                "centroid out of [-1, 1]: {val}",
-            );
-        }
-        Ok(())
-    }
-
-    #[test]
-    fn centroids_cached() -> VortexResult<()> {
-        let c1 = compute_or_get_centroids(128, 2)?;
-        let c2 = compute_or_get_centroids(128, 2)?;
-        assert_eq!(c1, c2);
-        Ok(())
-    }
-
-    #[test]
-    fn find_nearest_basic() -> VortexResult<()> {
-        let centroids = compute_or_get_centroids(128, 2)?;
-        let boundaries = compute_centroid_boundaries(&centroids);
-        assert_eq!(find_nearest_centroid(-1.0, &boundaries), 0);
-
-        #[expect(clippy::cast_possible_truncation)]
-        let last_idx = (centroids.len() - 1) as u8;
-        assert_eq!(find_nearest_centroid(1.0, &boundaries), last_idx);
-        for (idx, &cv) in centroids.iter().enumerate() {
-            #[expect(clippy::cast_possible_truncation)]
-            let expected = idx as u8;
-            assert_eq!(find_nearest_centroid(cv, &boundaries), expected);
-        }
-        Ok(())
-    }
-
-    #[test]
-    fn rejects_invalid_params() {
-        assert!(compute_or_get_centroids(128, 0).is_err());
-        assert!(compute_or_get_centroids(128, 9).is_err());
-        assert!(compute_or_get_centroids(1, 2).is_err());
-        assert!(compute_or_get_centroids(127, 2).is_err());
-    }
-}
diff --git a/vortex-turboquant/src/config.rs b/vortex-turboquant/src/config.rs
deleted file mode 100644
index 57cd8b1e94b..00000000000
--- a/vortex-turboquant/src/config.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::fmt;
-
-use vortex_error::VortexResult;
-use vortex_error::vortex_ensure;
-
-/// Minimum vector dimension for TurboQuant encoding.
-///
-/// Note that this is not a theoretical minimum, it is mostly a practical one to limit the total
-/// amount of distortion.
-pub(crate) const MIN_DIMENSION: u32 = 128;
-
-/// Maximum supported number of bits per quantized coordinate.
-pub(crate) const MAX_BIT_WIDTH: u8 = 8;
-
-/// Configuration for lossy TurboQuant encoding.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct TurboQuantConfig {
-    bit_width: u8,
-    seed: u64,
-    num_rounds: u8,
-}
-
-impl TurboQuantConfig {
-    /// Build a TurboQuant configuration.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if `bit_width` is outside `1..=8` or `num_rounds` is zero.
-    pub fn try_new(bit_width: u8, seed: u64, num_rounds: u8) -> VortexResult<Self> {
-        vortex_ensure!(
-            (1..=MAX_BIT_WIDTH).contains(&bit_width),
-            "TurboQuant bit_width must be 1-{MAX_BIT_WIDTH}, got {bit_width}",
-        );
-        vortex_ensure!(
-            num_rounds > 0,
-            "TurboQuant num_rounds must be > 0, got {num_rounds}"
-        );
-
-        Ok(Self {
-            bit_width,
-            seed,
-            num_rounds,
-        })
-    }
-
-    /// Bits per coordinate in the scalar quantizer codebook.
-    pub fn bit_width(&self) -> u8 {
-        self.bit_width
-    }
-
-    /// Seed used to derive the deterministic SORF transform.
-    pub fn seed(&self) -> u64 {
-        self.seed
-    }
-
-    /// Number of sign-diagonal plus Walsh-Hadamard rounds in the SORF transform.
-    pub fn num_rounds(&self) -> u8 {
-        self.num_rounds
-    }
-}
-
-impl Default for TurboQuantConfig {
-    /// Defaults to 8 bits per coordinate, seed 42, and 3 SORF rounds.
-    fn default() -> Self {
-        Self {
-            bit_width: MAX_BIT_WIDTH,
-            seed: 42,
-            num_rounds: 3,
-        }
-    }
-}
-
-impl fmt::Display for TurboQuantConfig {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "bit_width: {}, seed: {}, num_rounds: {}",
-            self.bit_width, self.seed, self.num_rounds
-        )
-    }
-}
diff --git a/vortex-turboquant/src/lib.rs b/vortex-turboquant/src/lib.rs
deleted file mode 100644
index 7aeb60368dd..00000000000
--- a/vortex-turboquant/src/lib.rs
+++ /dev/null
@@ -1,81 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! TurboQuant vector quantization extension type for Vortex.
-//!
-//! Implements a Stage 1 TurboQuant encoding ([arXiv:2504.19874], [RFC 0033]) for lossy compression
-//! of high-dimensional vector data. The extension operates on
-//! [`Vector`](vortex_tensor::vector::Vector) extension arrays, encoding their `FixedSizeList`
-//! storage into quantized codes after a structured orthogonal surrogate transform.
-//!
-//! [arXiv:2504.19874]: https://arxiv.org/abs/2504.19874
-//! [RFC 0033]: https://vortex-data.github.io/rfcs/rfc/0033.html
-//!
-//! # Overview
-//!
-//! TurboQuant minimizes mean-squared reconstruction error (1-8 bits per coordinate)
-//! using MSE-optimal scalar quantization on coordinates of a transformed unit vector.
-//!
-//! The [`TQEncode`] scalar function first computes and stores the original L2 norm for each vector
-//! row, then normalizes each valid nonzero row internally before SORF transform and scalar
-//! quantization. The [`TQDecode`] scalar function dequantizes through deterministic centroids,
-//! applies the inverse SORF transform, truncates back to the original dimension, and re-applies the
-//! stored norm.
-//!
-//! The encoded storage is a row-aligned extension tree:
-//!
-//! ```text
-//! Extension<TurboQuant>(
-//!     Struct {
-//!         norms: Primitive<element_ptype, vector_validity>,
-//!         codes: FixedSizeList<Primitive<u8>, padded_dim, vector_validity>,
-//!     }
-//! )
-//! ```
-//!
-//! Stored norms are authoritative for future TurboQuant-aware scalar functions. Decoded quantized
-//! directions are not guaranteed to have unit norm after scalar quantization and inverse transform.
-//!
-//! # Source map
-//!
-//! Implementation details are documented next to the code that owns them:
-//!
-//! - `vector/storage.rs`: physical storage shape, full-length child arrays, and field-level
-//!   validity for null vectors.
-//! - `vector/normalize.rs`: TurboQuant-local normalization and how it differs from the tensor
-//!   crate's null-row zeroing helper.
-//! - `vector/quantize.rs`: SORF transform, centroid lookup, and why invalid rows are skipped rather
-//!   than quantized.
-//! - `centroids.rs`: deterministic Max-Lloyd centroid computation and process-local caching.
-//! - `sorf/`: the Walsh-Hadamard-based structured transform and the stable SplitMix64 sign stream.
-//!
-//! The current encoding is intentionally MSE-only. It does not yet implement the paper's QJL
-//! residual correction for unbiased inner-product estimation, and it still uses internal
-//! power-of-2 padding rather than the block decomposition proposed in RFC 0033.
-
-mod centroids;
-mod config;
-mod scalar_fns;
-mod sorf;
-mod vector;
-mod vtable;
-
-pub use config::TurboQuantConfig;
-pub use scalar_fns::TQDecode;
-pub use scalar_fns::TQEncode;
-pub use vtable::TurboQuant;
-pub use vtable::TurboQuantMetadata;
-
-// TODO(connor): We need to somehow make sure that callers call `vortex_tensor::initialize` first.
-/// Register the TurboQuant extension type with a Vortex session.
-pub fn initialize(session: &vortex_session::VortexSession) {
-    use vortex_array::dtype::session::DTypeSessionExt;
-    use vortex_array::scalar_fn::session::ScalarFnSessionExt;
-    session.dtypes().register(TurboQuant);
-
-    session.scalar_fns().register(TQEncode);
-    session.scalar_fns().register(TQDecode);
-}
-
-#[cfg(test)]
-mod tests;
diff --git a/vortex-turboquant/src/scalar_fns/decode.rs b/vortex-turboquant/src/scalar_fns/decode.rs
deleted file mode 100644
index 6791a1aef61..00000000000
--- a/vortex-turboquant/src/scalar_fns/decode.rs
+++ /dev/null
@@ -1,317 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! TurboQuant decode scalar function.
-
-use std::fmt;
-use std::fmt::Formatter;
-use std::sync::Arc;
-
-use num_traits::Float;
-use num_traits::FromPrimitive;
-use vortex_array::ArrayRef;
-use vortex_array::ExecutionCtx;
-use vortex_array::IntoArray;
-use vortex_array::arrays::FixedSizeListArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::ScalarFnArray;
-use vortex_array::dtype::DType;
-use vortex_array::dtype::NativePType;
-use vortex_array::dtype::Nullability;
-use vortex_array::dtype::extension::ExtDType;
-use vortex_array::expr::Expression;
-use vortex_array::extension::EmptyMetadata;
-use vortex_array::match_each_float_ptype;
-use vortex_array::scalar_fn::Arity;
-use vortex_array::scalar_fn::ChildName;
-use vortex_array::scalar_fn::ExecutionArgs;
-use vortex_array::scalar_fn::ScalarFnId;
-use vortex_array::scalar_fn::ScalarFnVTable;
-use vortex_array::scalar_fn::TypedScalarFnInstance;
-use vortex_array::validity::Validity;
-use vortex_buffer::BufferMut;
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
-use vortex_error::vortex_ensure;
-use vortex_error::vortex_err;
-use vortex_mask::Mask;
-use vortex_session::VortexSession;
-use vortex_tensor::vector::Vector;
-
-use crate::centroids::compute_or_get_centroids;
-use crate::sorf::SorfMatrix;
-use crate::vector::storage::parse_storage;
-use crate::vector::tq_padded_dim;
-use crate::vtable::TurboQuantMetadata;
-use crate::vtable::tq_metadata;
-
-/// Lazy TurboQuant vector decode scalar function.
-#[derive(Clone)]
-pub struct TQDecode;
-
-impl TQDecode {
-    /// Creates a new [`TypedScalarFnInstance`] wrapping TurboQuant decoding.
-    pub fn new() -> TypedScalarFnInstance<TQDecode> {
-        TypedScalarFnInstance::new(TQDecode, EmptyMetadata)
-    }
-
-    /// Constructs a [`ScalarFnArray`] that lazily decodes a `TurboQuant` child into a `Vector`.
-    pub fn try_new_array(child: ArrayRef) -> VortexResult<ScalarFnArray> {
-        let len = child.len();
-        ScalarFnArray::try_new(TQDecode::new().erased(), vec![child], len)
-    }
-}
-
-impl ScalarFnVTable for TQDecode {
-    type Options = EmptyMetadata;
-
-    fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.turboquant.decode")
-    }
-
-    fn serialize(&self, _options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(vec![]))
-    }
-
-    fn deserialize(
-        &self,
-        metadata: &[u8],
-        _session: &VortexSession,
-    ) -> VortexResult<Self::Options> {
-        vortex_ensure!(
-            metadata.is_empty(),
-            "TQDecode options metadata must be empty"
-        );
-
-        Ok(EmptyMetadata)
-    }
-
-    fn arity(&self, _options: &Self::Options) -> Arity {
-        Arity::Exact(1)
-    }
-
-    fn child_name(&self, _options: &Self::Options, child_idx: usize) -> ChildName {
-        match child_idx {
-            0 => ChildName::from("turboquant"),
-            _ => unreachable!("TQDecode must have exactly one child"),
-        }
-    }
-
-    fn fmt_sql(
-        &self,
-        _options: &Self::Options,
-        expr: &Expression,
-        f: &mut Formatter<'_>,
-    ) -> fmt::Result {
-        write!(f, "tq_decode(")?;
-        expr.child(0).fmt_sql(f)?;
-        write!(f, ")")
-    }
-
-    fn return_dtype(&self, _options: &Self::Options, arg_dtypes: &[DType]) -> VortexResult<DType> {
-        let child_dtype = &arg_dtypes[0];
-        let metadata = tq_metadata(child_dtype)?;
-
-        let storage_dtype = DType::FixedSizeList(
-            Arc::new(DType::Primitive(
-                metadata.element_ptype,
-                Nullability::NonNullable,
-            )),
-            metadata.dimensions,
-            child_dtype.nullability(),
-        );
-        let ext_dtype = ExtDType::<Vector>::try_new(EmptyMetadata, storage_dtype)?.erased();
-
-        Ok(DType::Extension(ext_dtype))
-    }
-
-    fn execute(
-        &self,
-        _options: &Self::Options,
-        args: &dyn ExecutionArgs,
-        ctx: &mut ExecutionCtx,
-    ) -> VortexResult<ArrayRef> {
-        decode_vector(args.get(0)?, ctx)
-    }
-
-    fn validity(
-        &self,
-        _options: &Self::Options,
-        expression: &Expression,
-    ) -> VortexResult<Option<Expression>> {
-        Ok(Some(expression.child(0).validity()?))
-    }
-
-    fn is_null_sensitive(&self, _options: &Self::Options) -> bool {
-        false
-    }
-
-    fn is_fallible(&self, _options: &Self::Options) -> bool {
-        false
-    }
-}
-
-/// Decode a `TurboQuant` extension array back into a `Vector` extension array.
-///
-/// The decoded directions are inverse-transformed, truncated to the original dimension, and
-/// multiplied by the stored row norms. The conversion is lossy and does not roundtrip with
-/// [`TQEncode`](crate::TQEncode).
-pub(crate) fn decode_vector(input: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-    let parsed = parse_storage(input, ctx)?;
-    let metadata = parsed.metadata;
-    if parsed.len == 0 {
-        return build_empty_vector(metadata, parsed.vector_validity);
-    }
-
-    let padded_dim = tq_padded_dim(metadata.dimensions)?;
-    let transform = SorfMatrix::try_new(padded_dim, metadata.num_rounds as usize, metadata.seed)?;
-    let padded_dim = u32::try_from(padded_dim)
-        .map_err(|_| vortex_err!("TurboQuant padded dimension does not fit u32"))?;
-
-    let centroids = compute_or_get_centroids(padded_dim, metadata.bit_width)?;
-
-    match_each_float_ptype!(metadata.element_ptype, |T| {
-        decode_typed::<T>(
-            DecodeInputs {
-                metadata: &metadata,
-                sorf_matrix: &transform,
-                centroids: &centroids,
-                norms: &parsed.norms,
-                codes: &parsed.codes,
-            },
-            parsed.vector_validity,
-            parsed.len,
-            ctx,
-        )
-    })
-}
-
-fn build_empty_vector(
-    metadata: TurboQuantMetadata,
-    vector_validity: Validity,
-) -> VortexResult<ArrayRef> {
-    match_each_float_ptype!(metadata.element_ptype, |T| {
-        let elements = PrimitiveArray::empty::<T>(Nullability::NonNullable);
-        let fsl = FixedSizeListArray::try_new(
-            elements.into_array(),
-            metadata.dimensions,
-            vector_validity,
-            0,
-        )?;
-
-        Vector::try_new_vector_array(fsl.into_array())
-    })
-}
-
-/// Borrowed bundle of the per-array decode inputs passed to the typed inner loop.
-///
-/// Packaged as a struct rather than positional arguments because `decode_typed` runs through
-/// [`vortex_array::match_each_float_ptype!`] which expands once per supported element ptype.
-/// Each expansion takes the same set of inputs, and the struct keeps the call site short.
-struct DecodeInputs<'a> {
-    /// TurboQuant metadata recovered from the input extension dtype.
-    metadata: &'a TurboQuantMetadata,
-    /// SORF transform reconstructed from `metadata.seed` and `metadata.num_rounds`.
-    sorf_matrix: &'a SorfMatrix,
-    /// Centroid codebook for `(padded_dim, bit_width)`, in f32.
-    centroids: &'a [f32],
-    /// Per-row stored L2 norm of the original input vector, in the element ptype.
-    norms: &'a PrimitiveArray,
-    /// Flat per-row centroid indices, `num_vectors * padded_dim` bytes.
-    codes: &'a PrimitiveArray,
-}
-
-fn decode_typed<T>(
-    decode: DecodeInputs<'_>,
-    vector_validity: Validity,
-    num_vectors: usize,
-    ctx: &mut ExecutionCtx,
-) -> VortexResult<ArrayRef>
-where
-    T: NativePType + Float + FromPrimitive,
-{
-    let metadata = decode.metadata;
-    let dimensions = usize::try_from(metadata.dimensions)
-        .vortex_expect("dimensions stays representable as usize");
-    let padded_dim = decode.sorf_matrix.padded_dim();
-    let centroids = decode.centroids;
-    let norms = decode.norms.as_slice::<T>();
-    let codes = decode.codes.as_slice::<u8>();
-    let mask = vector_validity.execute_mask(num_vectors, ctx)?;
-
-    let output_len = num_vectors
-        .checked_mul(dimensions)
-        .ok_or_else(|| vortex_err!("TurboQuant decoded vector length overflow"))?;
-    let mut output = BufferMut::<T>::with_capacity(output_len);
-
-    let mut decoded = vec![0.0f32; padded_dim];
-    let mut inverse = vec![0.0f32; padded_dim];
-
-    let mut decode_row = |output: &mut BufferMut<T>, i: usize| {
-        let code_row = &codes[i * padded_dim..][..padded_dim];
-
-        for (dst, &code) in decoded.iter_mut().zip(code_row.iter()) {
-            *dst = *centroids
-                .get(usize::from(code))
-                .vortex_expect("TurboQuant code exceeds centroid count");
-        }
-
-        decode.sorf_matrix.inverse_transform(&decoded, &mut inverse);
-
-        let norm = norms[i];
-        for &value in inverse.iter().take(dimensions) {
-            // `T::from_f32` is infallible for the supported float ptypes (`f16`, `f32`,
-            // `f64`): values outside `f16` range saturate to `±inf` rather than returning
-            // `None`.
-            let value = T::from_f32(value)
-                .vortex_expect("from_f32 is infallible for supported float types");
-
-            // SAFETY: total pushes across all match arms equal `output_len`.
-            unsafe { output.push_unchecked(value * norm) };
-        }
-    };
-
-    match &mask {
-        Mask::AllFalse(_) => {
-            // SAFETY: `output` was allocated with capacity `output_len`, and this push writes
-            // exactly `output_len` zero placeholders.
-            unsafe { output.push_n_unchecked(T::zero(), output_len) };
-        }
-        Mask::AllTrue(_) => {
-            for i in 0..num_vectors {
-                decode_row(&mut output, i);
-            }
-        }
-        Mask::Values(values_mask) => {
-            let mut cursor = 0;
-
-            for &(start, end) in values_mask.slices() {
-                if start > cursor {
-                    // SAFETY: total pushes across all arms equal `output_len`.
-                    unsafe { output.push_n_unchecked(T::zero(), (start - cursor) * dimensions) };
-                }
-
-                for i in start..end {
-                    decode_row(&mut output, i);
-                }
-
-                cursor = end;
-            }
-
-            if cursor < num_vectors {
-                // SAFETY: total pushes across all arms equal `output_len`.
-                unsafe { output.push_n_unchecked(T::zero(), (num_vectors - cursor) * dimensions) };
-            }
-        }
-    }
-
-    let elements = PrimitiveArray::new::<T>(output.freeze(), Validity::NonNullable);
-    let fsl = FixedSizeListArray::try_new(
-        elements.into_array(),
-        metadata.dimensions,
-        vector_validity,
-        num_vectors,
-    )?;
-
-    Vector::try_new_vector_array(fsl.into_array())
-}
diff --git a/vortex-turboquant/src/scalar_fns/encode.rs b/vortex-turboquant/src/scalar_fns/encode.rs
deleted file mode 100644
index 29ce7cc580a..00000000000
--- a/vortex-turboquant/src/scalar_fns/encode.rs
+++ /dev/null
@@ -1,224 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! TurboQuant encode scalar function.
-
-use std::fmt;
-use std::fmt::Formatter;
-
-use vortex_array::ArrayRef;
-use vortex_array::ExecutionCtx;
-use vortex_array::IntoArray;
-use vortex_array::arrays::Extension;
-use vortex_array::arrays::ExtensionArray;
-use vortex_array::arrays::FixedSizeListArray;
-use vortex_array::arrays::ScalarFnArray;
-use vortex_array::arrays::extension::ExtensionArrayExt;
-use vortex_array::arrays::scalar_fn::ScalarFnArrayExt;
-use vortex_array::dtype::DType;
-use vortex_array::dtype::extension::ExtDType;
-use vortex_array::expr::Expression;
-use vortex_array::scalar_fn::Arity;
-use vortex_array::scalar_fn::ChildName;
-use vortex_array::scalar_fn::ExecutionArgs;
-use vortex_array::scalar_fn::ScalarFnId;
-use vortex_array::scalar_fn::ScalarFnVTable;
-use vortex_array::scalar_fn::TypedScalarFnInstance;
-use vortex_error::VortexResult;
-use vortex_error::vortex_ensure;
-use vortex_error::vortex_err;
-use vortex_session::VortexSession;
-use vortex_tensor::vector::AnyVector;
-
-use super::metadata::deserialize_config;
-use super::metadata::serialize_config;
-use crate::TurboQuantConfig;
-use crate::config::MIN_DIMENSION;
-use crate::vector::normalize::tq_normalize_as_l2_denorm;
-use crate::vector::quantize::empty_quantization;
-use crate::vector::quantize::turboquant_quantize_core;
-use crate::vector::storage::build_codes_child;
-use crate::vector::storage::build_storage;
-use crate::vector::tq_padded_dim;
-use crate::vtable::TurboQuant;
-use crate::vtable::TurboQuantMetadata;
-use crate::vtable::tq_storage_dtype;
-
-/// TurboQuant vector encode scalar function.
-///
-/// `TQEncode` itself is a `ScalarFnVTable` and so its options round-trip through expression
-/// serialization.
-///
-/// Unlike `TQDecode`, it deliberately does **not** implement `ScalarFnArrayVTable` since the
-/// persisted artifact would be the original vector array, not the TurboQuant-quantized array.
-#[derive(Clone)]
-pub struct TQEncode;
-
-impl TQEncode {
-    /// Creates a new [`TypedScalarFnInstance`] wrapping TurboQuant encoding.
-    pub fn new(config: &TurboQuantConfig) -> TypedScalarFnInstance<TQEncode> {
-        TypedScalarFnInstance::new(TQEncode, config.clone())
-    }
-
-    /// Constructs a [`ScalarFnArray`] that lazily encodes a `Vector` child into `TurboQuant`.
-    pub fn try_new_array(
-        child: ArrayRef,
-        config: &TurboQuantConfig,
-    ) -> VortexResult<ScalarFnArray> {
-        let len = child.len();
-        ScalarFnArray::try_new(TQEncode::new(config).erased(), vec![child], len)
-    }
-}
-
-impl ScalarFnVTable for TQEncode {
-    type Options = TurboQuantConfig;
-
-    fn id(&self) -> ScalarFnId {
-        ScalarFnId::new("vortex.turboquant.encode")
-    }
-
-    fn serialize(&self, options: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(serialize_config(options)))
-    }
-
-    fn deserialize(
-        &self,
-        metadata: &[u8],
-        _session: &VortexSession,
-    ) -> VortexResult<Self::Options> {
-        deserialize_config(metadata)
-    }
-
-    fn arity(&self, _options: &Self::Options) -> Arity {
-        Arity::Exact(1)
-    }
-
-    fn child_name(&self, _options: &Self::Options, child_idx: usize) -> ChildName {
-        match child_idx {
-            0 => ChildName::from("vector"),
-            _ => unreachable!("TQEncode must have exactly one child"),
-        }
-    }
-
-    fn fmt_sql(
-        &self,
-        options: &Self::Options,
-        expr: &Expression,
-        f: &mut Formatter<'_>,
-    ) -> fmt::Result {
-        write!(f, "tq_encode(")?;
-        expr.child(0).fmt_sql(f)?;
-        write!(f, ", {options})")
-    }
-
-    fn return_dtype(&self, options: &Self::Options, arg_dtypes: &[DType]) -> VortexResult<DType> {
-        let input_dtype = &arg_dtypes[0];
-        let vector_metadata = input_dtype
-            .as_extension_opt()
-            .and_then(|ext_dtype| ext_dtype.metadata_opt::<AnyVector>())
-            .ok_or_else(|| {
-                vortex_err!("TQEncode expects a Vector extension array, got {input_dtype}")
-            })?;
-
-        let dimensions = vector_metadata.dimensions();
-        vortex_ensure!(
-            dimensions >= MIN_DIMENSION,
-            "TurboQuant requires dimension >= {MIN_DIMENSION}, got {dimensions}",
-        );
-        tq_padded_dim(dimensions)?;
-
-        let metadata = TurboQuantMetadata {
-            element_ptype: vector_metadata.element_ptype(),
-            dimensions,
-            bit_width: options.bit_width(),
-            seed: options.seed(),
-            num_rounds: options.num_rounds(),
-        };
-        let storage_dtype = tq_storage_dtype(&metadata, input_dtype.nullability())?;
-        let ext_dtype = ExtDType::<TurboQuant>::try_new(metadata, storage_dtype)?.erased();
-
-        Ok(DType::Extension(ext_dtype))
-    }
-
-    fn execute(
-        &self,
-        options: &Self::Options,
-        args: &dyn ExecutionArgs,
-        ctx: &mut ExecutionCtx,
-    ) -> VortexResult<ArrayRef> {
-        encode_vector(args.get(0)?, options, ctx)
-    }
-
-    fn validity(
-        &self,
-        _options: &Self::Options,
-        expression: &Expression,
-    ) -> VortexResult<Option<Expression>> {
-        Ok(Some(expression.child(0).validity()?))
-    }
-
-    fn is_null_sensitive(&self, _options: &Self::Options) -> bool {
-        false
-    }
-
-    fn is_fallible(&self, _options: &Self::Options) -> bool {
-        false
-    }
-}
-
-/// Lossily encode a `Vector` extension array into a `TurboQuant` extension array.
-///
-/// Valid rows are normalized internally before SORF transform and scalar quantization. The original
-/// row norms are stored explicitly, and original vector nulls are preserved on the storage struct
-/// and both row-aligned child arrays.
-pub(crate) fn encode_vector(
-    input: ArrayRef,
-    config: &TurboQuantConfig,
-    ctx: &mut ExecutionCtx,
-) -> VortexResult<ArrayRef> {
-    let num_vectors = input.len();
-    let vector_metadata = input
-        .dtype()
-        .as_extension_opt()
-        .and_then(|ext_dtype| ext_dtype.metadata_opt::<AnyVector>())
-        .ok_or_else(|| vortex_err!("TurboQuant encode expects a Vector extension array"))?;
-
-    let element_ptype = vector_metadata.element_ptype();
-
-    let dimensions = vector_metadata.dimensions();
-    vortex_ensure!(
-        dimensions >= MIN_DIMENSION,
-        "TurboQuant requires dimension >= {MIN_DIMENSION}, got {dimensions}",
-    );
-    let padded_dim = tq_padded_dim(dimensions)?;
-
-    let vector_validity = input.validity()?;
-
-    let l2_denorm = tq_normalize_as_l2_denorm(input, ctx)?;
-    let normalized = l2_denorm.child_at(0).clone();
-    let norms = l2_denorm.child_at(1).clone();
-
-    let normalized_ext = normalized
-        .as_opt::<Extension>()
-        .ok_or_else(|| vortex_err!("normalized TurboQuant input must be a Vector extension"))?;
-    let normalized_fsl: FixedSizeListArray = normalized_ext.storage_array().clone().execute(ctx)?;
-
-    let core = if normalized_fsl.is_empty() {
-        empty_quantization(padded_dim)
-    } else {
-        // SAFETY: `tq_normalize_as_l2_denorm` returned this normalized Vector child.
-        unsafe { turboquant_quantize_core(&normalized_fsl, config, ctx)? }
-    };
-    let codes = build_codes_child(num_vectors, core, vector_validity.clone())?;
-
-    let metadata = TurboQuantMetadata {
-        element_ptype,
-        dimensions,
-        bit_width: config.bit_width(),
-        seed: config.seed(),
-        num_rounds: config.num_rounds(),
-    };
-    let storage = build_storage(norms, codes, num_vectors, vector_validity)?;
-
-    Ok(ExtensionArray::try_new_from_vtable(TurboQuant, metadata, storage)?.into_array())
-}
diff --git a/vortex-turboquant/src/scalar_fns/metadata.rs b/vortex-turboquant/src/scalar_fns/metadata.rs
deleted file mode 100644
index f5eddfe51d9..00000000000
--- a/vortex-turboquant/src/scalar_fns/metadata.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use prost::Message;
-use vortex_error::VortexResult;
-use vortex_error::vortex_err;
-
-use crate::TurboQuantConfig;
-
-#[derive(Clone, PartialEq, Message)]
-pub(super) struct TQScalarFnMetadata {
-    #[prost(uint32, tag = "1")]
-    bit_width: u32,
-    #[prost(uint64, tag = "2")]
-    seed: u64,
-    #[prost(uint32, tag = "3")]
-    num_rounds: u32,
-}
-
-impl TQScalarFnMetadata {
-    pub(super) fn from_config(config: &TurboQuantConfig) -> Self {
-        Self {
-            bit_width: u32::from(config.bit_width()),
-            seed: config.seed(),
-            num_rounds: u32::from(config.num_rounds()),
-        }
-    }
-
-    pub(super) fn to_config(&self) -> VortexResult<TurboQuantConfig> {
-        let bit_width = u8::try_from(self.bit_width)
-            .map_err(|_| vortex_err!("TurboQuant bit_width does not fit u8"))?;
-        let num_rounds = u8::try_from(self.num_rounds)
-            .map_err(|_| vortex_err!("TurboQuant num_rounds does not fit u8"))?;
-
-        TurboQuantConfig::try_new(bit_width, self.seed, num_rounds)
-    }
-}
-
-pub(super) fn serialize_config(config: &TurboQuantConfig) -> Vec<u8> {
-    TQScalarFnMetadata::from_config(config).encode_to_vec()
-}
-
-pub(super) fn deserialize_config(metadata: &[u8]) -> VortexResult<TurboQuantConfig> {
-    TQScalarFnMetadata::decode(metadata)
-        .map_err(|e| vortex_err!("Failed to decode TurboQuant scalar function metadata: {e}"))?
-        .to_config()
-}
diff --git a/vortex-turboquant/src/scalar_fns/mod.rs b/vortex-turboquant/src/scalar_fns/mod.rs
deleted file mode 100644
index 1acea9f70f3..00000000000
--- a/vortex-turboquant/src/scalar_fns/mod.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Scalar functions for lazy TurboQuant vector encode and decode operations.
-
-mod decode;
-mod encode;
-mod metadata;
-
-pub use decode::TQDecode;
-pub use encode::TQEncode;
diff --git a/vortex-turboquant/src/sorf/splitmix64.rs b/vortex-turboquant/src/sorf/splitmix64.rs
deleted file mode 100644
index fc3f9073ced..00000000000
--- a/vortex-turboquant/src/sorf/splitmix64.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Frozen local SplitMix64 stream used to define SORF sign diagonals.
-//!
-//! This is a direct translation of the `splitmix64.c` [reference implementation][impl].
-//!
-//! The state is a single `u64`, and `next_u64()` first adds [`SPLITMIX64_INCREMENT`] with wrapping
-//! arithmetic, then applies the two reference mixing steps and final xor-shift.
-//!
-//! [impl]: https://prng.di.unimi.it/splitmix64.c
-
-/// SplitMix64 additive constant from the reference implementation.
-const SPLITMIX64_INCREMENT: u64 = 0x9E37_79B9_7F4A_7C15;
-
-/// First SplitMix64 mixing multiplier from the reference implementation.
-const SPLITMIX64_MUL1: u64 = 0xBF58_476D_1CE4_E5B9;
-
-/// Second SplitMix64 mixing multiplier from the reference implementation.
-const SPLITMIX64_MUL2: u64 = 0x94D0_49BB_1331_11EB;
-
-/// Frozen local SplitMix64 stream used to define SORF sign diagonals. Bit-identical to the
-/// reference implementation linked at the module top, which makes the sign stream part of the
-/// encoding's wire contract.
-pub(crate) struct SplitMix64 {
-    state: u64,
-}
-
-impl SplitMix64 {
-    pub(crate) fn new(seed: u64) -> Self {
-        Self { state: seed }
-    }
-
-    pub(crate) fn next_u64(&mut self) -> u64 {
-        self.state = self.state.wrapping_add(SPLITMIX64_INCREMENT);
-        let mut z = self.state;
-        z = (z ^ (z >> 30)).wrapping_mul(SPLITMIX64_MUL1);
-        z = (z ^ (z >> 27)).wrapping_mul(SPLITMIX64_MUL2);
-        z ^ (z >> 31)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::SplitMix64;
-
-    const SPLITMIX64_SEED0_GOLDEN: [u64; 4] = [
-        0xE220_A839_7B1D_CDAF,
-        0x6E78_9E6A_A1B9_65F4,
-        0x06C4_5D18_8009_454F,
-        0xF88B_B8A8_724C_81EC,
-    ];
-
-    const SPLITMIX64_SEED42_GOLDEN: [u64; 4] = [
-        0xBDD7_3226_2FEB_6E95,
-        0x28EF_E333_B266_F103,
-        0x4752_6757_130F_9F52,
-        0x581C_E1FF_0E4A_E394,
-    ];
-
-    #[test]
-    fn splitmix64_seed0_matches_golden_outputs() {
-        let mut rng = SplitMix64::new(0);
-        let actual: Vec<_> = (0..SPLITMIX64_SEED0_GOLDEN.len())
-            .map(|_| rng.next_u64())
-            .collect();
-        assert_eq!(actual, SPLITMIX64_SEED0_GOLDEN);
-    }
-
-    #[test]
-    fn splitmix64_seed42_matches_golden_outputs() {
-        let mut rng = SplitMix64::new(42);
-        let actual: Vec<_> = (0..SPLITMIX64_SEED42_GOLDEN.len())
-            .map(|_| rng.next_u64())
-            .collect();
-        assert_eq!(actual, SPLITMIX64_SEED42_GOLDEN);
-    }
-}
diff --git a/vortex-turboquant/src/sorf/transform.rs b/vortex-turboquant/src/sorf/transform.rs
deleted file mode 100644
index 3fa221fe03a..00000000000
--- a/vortex-turboquant/src/sorf/transform.rs
+++ /dev/null
@@ -1,419 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! SORF (Structured Orthogonal Random Features) orthogonal transform.
-//!
-//! Implements the SORF construction from [Yu et al. 2016][sorf-paper]: a fast structured
-//! approximation to a random orthogonal matrix using random sign diagonals interleaved with the
-//! Fast Walsh-Hadamard Transform (FWHT).
-//!
-//! [sorf-paper]: https://proceedings.neurips.cc/paper_files/paper/2016/file/53adaf494dc89ef7196d73636eb2451b-Paper.pdf
-//!
-//! For `k` rounds, the transform is `norm * H * D_k * ... * H * D_1 * x`, where `D_1` is the
-//! first sign diagonal applied. The number of rounds is configurable (typically 3). Each round
-//! applies a random sign diagonal `D_i` and then the Hadamard matrix `H`, giving O(d log d) cost
-//! per matrix-vector product instead of the O(d^2) cost of a dense orthogonal matrix.
-//!
-//! This implementation defines those sign diagonals using a frozen local SplitMix64 stream rather
-//! than an
-//! external RNG crate. The contract is:
-//!
-//! - state is a single `u64` seed,
-//! - each `next_u64()` call uses the SplitMix64 reference algorithm with wrapping `u64`
-//!   arithmetic,
-//! - signs are generated in round-major, block-major order,
-//! - each generated `u64` contributes 64 signs in least-significant-bit-first order,
-//! - bit `1` means `+1` and bit `0` means `-1`.
-//!
-//! This makes SORF sign generation stable as an extension format contract even if external RNG
-//! implementations change.
-//!
-//! This transform is the crate's practical structured transform choice for TurboQuant. It is not
-//! the dense random Gaussian or orthogonal matrix used by some theoretical analyses, so theoretical
-//! bounds from those models need separate validation before being presented as implementation
-//! guarantees.
-//!
-//! The FWHT exploits the Kronecker product structure of the Hadamard matrix (`H_n = H_2 (x) H_2
-//! (x) ... (x) H_2`, with `log2(n)` factors) to compute the matrix-vector product in O(n log n)
-//! time using only in-place 2-element butterfly operations. No row of the full n x n Hadamard
-//! matrix is ever materialized.
-//!
-//! For dimensions that are not powers of 2, the input is zero-padded to the next power of 2 before
-//! the transform and truncated afterward.
-//!
-//! # Sign representation
-//!
-//! Signs are stored internally as `u32` XOR masks: `0x00000000` for +1 (no-op) and `0x80000000` for
-//! -1 (flip IEEE 754 sign bit). The sign application function uses integer XOR instead of
-//! floating-point multiply, which avoids FP dependency chains and auto-vectorizes into
-//! `vpxor`/`veor`.
-
-use vortex_error::VortexResult;
-use vortex_error::vortex_ensure;
-
-use super::splitmix64::SplitMix64;
-
-/// IEEE 754 sign bit mask for f32.
-const F32_SIGN_BIT: u32 = 0x8000_0000;
-
-/// A Walsh-Hadamard-based structured orthogonal transform matrix.
-///
-/// All computation is done in f32. The sign diagonals are stored as IEEE 754 XOR masks on
-/// f32 bit patterns, and the Walsh-Hadamard butterfly operates on `&mut [f32]` slices.
-pub(crate) struct SorfMatrix {
-    /// Flat XOR masks for all `num_rounds` diagonal matrices, total length
-    /// `num_rounds * padded_dim`.
-    ///
-    /// Indexed as `round * padded_dim + i`. `0x00000000` = multiply by +1 (no-op), `0x80000000` =
-    /// multiply by -1 (flip sign bit).
-    sign_masks: Vec<u32>,
-
-    /// The number of sign-diagonal + WHT rounds.
-    num_rounds: usize,
-
-    /// The padded dimension (next power of 2 >= dimension).
-    padded_dim: usize,
-
-    /// Normalization factor: `padded_dim^(-num_rounds/2)`, applied once at the end.
-    ///
-    /// This is stored for convenience.
-    norm_factor: f32,
-}
-
-impl SorfMatrix {
-    /// Create a new structured Walsh-Hadamard-based orthogonal transform for a padded dimension.
-    ///
-    /// `padded_dimensions` must already be a power of two. Callers that start from an unpadded
-    /// logical dimension are responsible for padding it before constructing the matrix.
-    pub(crate) fn try_new(
-        padded_dimensions: usize,
-        num_rounds: usize,
-        seed: u64,
-    ) -> VortexResult<Self> {
-        vortex_ensure!(num_rounds >= 1, "num_rounds must be >= 1, got {num_rounds}");
-        vortex_ensure!(
-            padded_dimensions.is_power_of_two(),
-            "padded_dimensions must be a power of two, got {padded_dimensions}"
-        );
-
-        let padded_dim = padded_dimensions;
-        let sign_masks = gen_sign_masks_from_seed(seed, padded_dim, num_rounds);
-
-        // Compute in f64 for precision, then store as f32 since the WHT operates on f32 buffers.
-        // The result is always in (0, 1] for any valid padded_dim >= 2 and num_rounds >= 1, so
-        // the f64 -> f32 cast is a precision loss only (it cannot overflow to infinity).
-        #[expect(
-            clippy::cast_possible_truncation,
-            reason = "the norm factor is in (0, 1] so the f64 -> f32 cast cannot overflow"
-        )]
-        let norm_factor = (padded_dim as f64).powf(-(num_rounds as f64) / 2.0) as f32;
-
-        Ok(Self {
-            sign_masks,
-            num_rounds,
-            padded_dim,
-            norm_factor,
-        })
-    }
-
-    /// Returns the padded dimension (next power of 2 >= dim).
-    ///
-    /// All `transform`/`inverse_transform` buffers must be this length.
-    pub(crate) fn padded_dim(&self) -> usize {
-        self.padded_dim
-    }
-
-    /// Apply the forward orthogonal transform: `output = R(input)`.
-    ///
-    /// Both `input` and `output` must have length [`padded_dim()`](Self::padded_dim). The caller is
-    /// responsible for zero-padding input beyond `dim` positions.
-    pub(crate) fn transform(&self, input: &[f32], output: &mut [f32]) {
-        debug_assert_eq!(input.len(), self.padded_dim);
-        debug_assert_eq!(output.len(), self.padded_dim);
-
-        output.copy_from_slice(input);
-        self.apply_srht(output);
-    }
-
-    /// Apply the inverse orthogonal transform: `output = R⁻¹(input)`.
-    ///
-    /// Both `input` and `output` must have length `padded_dim()`.
-    pub(crate) fn inverse_transform(&self, input: &[f32], output: &mut [f32]) {
-        debug_assert_eq!(input.len(), self.padded_dim);
-        debug_assert_eq!(output.len(), self.padded_dim);
-
-        output.copy_from_slice(input);
-        self.apply_inverse_srht(output);
-    }
-
-    /// Apply the forward structured transform: `norm · H · D_k · ... · H · D₁ · x`.
-    fn apply_srht(&self, buf: &mut [f32]) {
-        for round in 0..self.num_rounds {
-            self.apply_signs_xor(buf, round);
-            walsh_hadamard_transform(buf);
-        }
-
-        buf.iter_mut().for_each(|val| *val *= self.norm_factor);
-    }
-
-    /// Apply the inverse structured transform.
-    ///
-    /// Forward is: `norm · H · D_k · ... · H · D₁`.
-    /// Inverse is: `norm · D₁ · H · ... · D_k · H`.
-    fn apply_inverse_srht(&self, buf: &mut [f32]) {
-        for round in (0..self.num_rounds).rev() {
-            walsh_hadamard_transform(buf);
-            self.apply_signs_xor(buf, round);
-        }
-
-        buf.iter_mut().for_each(|val| *val *= self.norm_factor);
-    }
-
-    /// Apply one round's sign masks via XOR on the IEEE 754 sign bit.
-    ///
-    /// This is branchless and auto-vectorizes into `vpxor` (x86) / `veor` (ARM). Equivalent to
-    /// multiplying each element by +/-1.0, but avoids FP dependency chains.
-    fn apply_signs_xor(&self, buf: &mut [f32], round: usize) {
-        let masks = &self.sign_masks[round * self.padded_dim..][..self.padded_dim];
-        for (val, &mask) in buf.iter_mut().zip(masks.iter()) {
-            *val = f32::from_bits(val.to_bits() ^ mask);
-        }
-    }
-}
-
-/// Generate XOR sign masks from the frozen local SplitMix64 stream.
-///
-/// Signs are produced in round-major, block-major order. For each block we call
-/// [`SplitMix64::next_u64`] exactly once and unpack its bits from least significant to most
-/// significant. Bit `1` means positive sign / `0x00000000`; bit `0` means negative sign /
-/// [`F32_SIGN_BIT`].
-fn gen_sign_masks_from_seed(seed: u64, padded_dim: usize, num_rounds: usize) -> Vec<u32> {
-    let mut rng = SplitMix64::new(seed);
-    let mut sign_masks = Vec::with_capacity(num_rounds * padded_dim);
-
-    for _round in 0..num_rounds {
-        for base_idx in (0..padded_dim).step_by(64) {
-            let word = rng.next_u64();
-            let bits_in_block = (padded_dim - base_idx).min(64);
-            sign_masks.extend((0..bits_in_block).map(|bit_idx| sign_mask_from_word(word, bit_idx)));
-        }
-    }
-
-    sign_masks
-}
-
-/// Convert one bit from a SplitMix64 output word into an XOR sign mask.
-fn sign_mask_from_word(word: u64, bit_idx: usize) -> u32 {
-    if ((word >> bit_idx) & 1) != 0 {
-        0u32
-    } else {
-        F32_SIGN_BIT
-    }
-}
-
-/// In-place Fast Walsh-Hadamard Transform (FWHT), unnormalized and iterative.
-///
-/// Input length must be a power of 2. Runs in O(n log n) via `log2(n)` stages of `n / 2`
-/// [`butterfly`] operations each. See the [module-level docs](self) for why this avoids
-/// materializing the full Hadamard matrix.
-///
-/// The chunk-based iteration gives LLVM enough structure to auto-vectorize each butterfly call
-/// into NEON/AVX SIMD instructions.
-fn walsh_hadamard_transform(buf: &mut [f32]) {
-    let len = buf.len();
-    debug_assert!(len.is_power_of_two());
-
-    let mut half = 1;
-    while half < len {
-        let stride = half * 2;
-        // Process in chunks of `stride` elements. Within each chunk,
-        // split into non-overlapping (lo, hi) halves for the butterfly.
-        for chunk in buf.chunks_exact_mut(stride) {
-            let (lo, hi) = chunk.split_at_mut(half);
-            butterfly(lo, hi);
-        }
-        half *= 2;
-    }
-}
-
-/// Butterfly: `(lo[i], hi[i]) -> (lo[i] + hi[i], lo[i] - hi[i])`.
-///
-/// This is multiplication by the 2x2 Hadamard kernel `H_2 = [[1, 1], [1, -1]]` on each element
-/// pair. Factored into a separate function so LLVM can see the slice lengths match and
-/// auto-vectorize.
-fn butterfly(lo: &mut [f32], hi: &mut [f32]) {
-    debug_assert_eq!(lo.len(), hi.len());
-    for (a, b) in lo.iter_mut().zip(hi.iter_mut()) {
-        let sum = *a + *b;
-        let diff = *a - *b;
-        *a = sum;
-        *b = diff;
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use rstest::rstest;
-    use vortex_error::VortexResult;
-
-    use super::*;
-
-    fn dim_to_usize(dim: u32) -> usize {
-        usize::try_from(dim).unwrap()
-    }
-
-    fn rounds_to_usize(num_rounds: u8) -> usize {
-        usize::from(num_rounds)
-    }
-
-    #[test]
-    fn deterministic_from_seed() -> VortexResult<()> {
-        let padded_dim = dim_to_usize(64u32);
-        let num_rounds = rounds_to_usize(3u8);
-        let seed = 42u64;
-        let transform1 = SorfMatrix::try_new(padded_dim, num_rounds, seed)?;
-        let transform2 = SorfMatrix::try_new(padded_dim, num_rounds, seed)?;
-        let pd = transform1.padded_dim();
-
-        let mut input = vec![0.0f32; pd];
-        for i in 0..padded_dim {
-            input[i] = i as f32;
-        }
-        let mut out1 = vec![0.0f32; pd];
-        let mut out2 = vec![0.0f32; pd];
-
-        transform1.transform(&input, &mut out1);
-        transform2.transform(&input, &mut out2);
-
-        assert_eq!(out1, out2);
-        Ok(())
-    }
-
-    #[test]
-    fn one_word_generates_64_signs_lsb_first() {
-        let seed = 42u64;
-        let padded_dim = dim_to_usize(64u32);
-        let num_rounds = rounds_to_usize(1u8);
-        let masks = gen_sign_masks_from_seed(seed, padded_dim, num_rounds);
-        assert_eq!(masks.len(), padded_dim);
-
-        let mut rng = SplitMix64::new(seed);
-        let word = rng.next_u64();
-        let expected: Vec<_> = (0..padded_dim)
-            .map(|bit_idx| sign_mask_from_word(word, bit_idx))
-            .collect();
-        assert_eq!(masks, expected);
-    }
-
-    #[test]
-    fn rejects_non_power_of_two_padded_dimensions() {
-        assert!(SorfMatrix::try_new(dim_to_usize(100u32), rounds_to_usize(3u8), 42u64).is_err());
-    }
-
-    #[test]
-    fn tail_block_uses_only_required_bits() {
-        let seed = 42u64;
-        let padded_dim = dim_to_usize(32u32);
-        let num_rounds = rounds_to_usize(1u8);
-        let masks = gen_sign_masks_from_seed(seed, padded_dim, num_rounds);
-        assert_eq!(masks.len(), padded_dim);
-
-        let mut rng = SplitMix64::new(seed);
-        let word = rng.next_u64();
-        let expected: Vec<_> = (0..padded_dim)
-            .map(|bit_idx| sign_mask_from_word(word, bit_idx))
-            .collect();
-        assert_eq!(masks, expected);
-    }
-
-    /// Verify roundtrip is exact to f32 precision across many dimensions and round counts,
-    /// including non-power-of-two dimensions that require padding.
-    #[rstest]
-    #[case(32u32, 3u8)]
-    #[case(64u32, 3u8)]
-    #[case(100u32, 3u8)]
-    #[case(128u32, 1u8)]
-    #[case(128u32, 2u8)]
-    #[case(128u32, 3u8)]
-    #[case(128u32, 5u8)]
-    #[case(256u32, 3u8)]
-    #[case(512u32, 3u8)]
-    #[case(768u32, 3u8)]
-    #[case(1024u32, 3u8)]
-    fn roundtrip_exact(#[case] dim: u32, #[case] num_rounds: u8) -> VortexResult<()> {
-        let dim = dim_to_usize(dim);
-        let num_rounds = rounds_to_usize(num_rounds);
-        let transform = SorfMatrix::try_new(dim.next_power_of_two(), num_rounds, 42u64)?;
-        let padded_dim = transform.padded_dim();
-
-        let mut input = vec![0.0f32; padded_dim];
-        for i in 0..dim {
-            input[i] = (i as f32 + 1.0) * 0.01;
-        }
-        let mut transformed = vec![0.0f32; padded_dim];
-        let mut recovered = vec![0.0f32; padded_dim];
-
-        transform.transform(&input, &mut transformed);
-        transform.inverse_transform(&transformed, &mut recovered);
-
-        let max_err: f32 = input
-            .iter()
-            .zip(recovered.iter())
-            .map(|(a, b)| (a - b).abs())
-            .fold(0.0f32, f32::max);
-        let max_val: f32 = input.iter().map(|x| x.abs()).fold(0.0f32, f32::max);
-        let rel_err = max_err / max_val;
-
-        // SRHT roundtrip should be exact up to f32 precision (~1e-6).
-        assert!(
-            rel_err < 1e-5,
-            "roundtrip relative error too large for dim={dim}, rounds={num_rounds}: {rel_err:.2e}"
-        );
-        Ok(())
-    }
-
-    /// Verify norm preservation across dimensions and round counts.
-    #[rstest]
-    #[case(128u32, 1u8)]
-    #[case(128u32, 3u8)]
-    #[case(128u32, 5u8)]
-    #[case(768u32, 3u8)]
-    fn preserves_norm(#[case] dim: u32, #[case] num_rounds: u8) -> VortexResult<()> {
-        let dim = dim_to_usize(dim);
-        let num_rounds = rounds_to_usize(num_rounds);
-        let transform = SorfMatrix::try_new(dim.next_power_of_two(), num_rounds, 7u64)?;
-        let padded_dim = transform.padded_dim();
-
-        let mut input = vec![0.0f32; padded_dim];
-        for i in 0..dim {
-            input[i] = (i as f32) * 0.01;
-        }
-        let input_norm: f32 = input.iter().map(|x| x * x).sum::<f32>().sqrt();
-
-        let mut transformed = vec![0.0f32; padded_dim];
-        transform.transform(&input, &mut transformed);
-        let transformed_norm: f32 = transformed.iter().map(|x| x * x).sum::<f32>().sqrt();
-
-        assert!(
-            (input_norm - transformed_norm).abs() / input_norm < 1e-5,
-            "norm not preserved for dim={dim}: {} vs {} (rel err: {:.2e})",
-            input_norm,
-            transformed_norm,
-            (input_norm - transformed_norm).abs() / input_norm
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn wht_basic() {
-        // WHT of [1, 0, 0, 0] should be [1, 1, 1, 1]
-        let mut buf = vec![1.0f32, 0.0, 0.0, 0.0];
-        walsh_hadamard_transform(&mut buf);
-        assert_eq!(buf, vec![1.0, 1.0, 1.0, 1.0]);
-
-        // WHT is self-inverse (up to scaling by n)
-        walsh_hadamard_transform(&mut buf);
-        // After two WHTs: each element multiplied by n=4
-        assert_eq!(buf, vec![4.0, 0.0, 0.0, 0.0]);
-    }
-}
diff --git a/vortex-turboquant/src/tests/encode_decode.rs b/vortex-turboquant/src/tests/encode_decode.rs
deleted file mode 100644
index ed5aab190aa..00000000000
--- a/vortex-turboquant/src/tests/encode_decode.rs
+++ /dev/null
@@ -1,254 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use rstest::rstest;
-use vortex_array::IntoArray;
-use vortex_array::VortexSessionExecute;
-use vortex_array::arrays::ExtensionArray;
-use vortex_array::arrays::FixedSizeListArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::extension::ExtensionArrayExt;
-use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
-use vortex_array::arrays::scalar_fn::ScalarFnArrayExt;
-use vortex_array::arrays::struct_::StructArrayExt;
-use vortex_array::dtype::Nullability;
-use vortex_array::dtype::PType;
-use vortex_array::validity::Validity;
-use vortex_buffer::Buffer;
-use vortex_error::VortexResult;
-
-use super::execute_tq_decode;
-use super::execute_tq_encode;
-use super::f32_vector_array;
-use super::test_session;
-use super::turboquant_storage;
-use super::vector_array;
-use super::vector_element_ptype;
-use super::vector_validity;
-use super::vector_values_f32;
-use crate::TurboQuantConfig;
-use crate::centroids::compute_or_get_centroids;
-use crate::vector::normalize::tq_normalize_as_l2_denorm;
-
-#[rstest]
-#[case::zero_bits(0, 42, 3)]
-#[case::too_many_bits(9, 42, 3)]
-#[case::zero_rounds(2, 42, 0)]
-fn config_rejects_invalid_values(#[case] bit_width: u8, #[case] seed: u64, #[case] num_rounds: u8) {
-    assert!(TurboQuantConfig::try_new(bit_width, seed, num_rounds).is_err());
-}
-
-#[test]
-fn encode_rejects_non_vector_input() {
-    let session = test_session();
-    let mut ctx = session.create_execution_ctx();
-    let input = PrimitiveArray::new::<f32>(Buffer::copy_from([1.0, 2.0]), Validity::NonNullable)
-        .into_array();
-
-    assert!(execute_tq_encode(input, &TurboQuantConfig::default(), &mut ctx).is_err());
-}
-
-#[test]
-fn encode_rejects_small_dimensions() -> VortexResult<()> {
-    let session = test_session();
-    let mut ctx = session.create_execution_ctx();
-    let input = f32_vector_array(127, 1, 1.0, Validity::NonNullable)?;
-
-    assert!(execute_tq_encode(input, &TurboQuantConfig::default(), &mut ctx).is_err());
-    Ok(())
-}
-
-#[test]
-fn encode_rejects_padded_dimension_overflow() -> VortexResult<()> {
-    let session = test_session();
-    let mut ctx = session.create_execution_ctx();
-    let input = vector_array::<f32>(2_147_483_649, &[], Validity::NonNullable)?;
-
-    assert!(execute_tq_encode(input, &TurboQuantConfig::default(), &mut ctx).is_err());
-    Ok(())
-}
-
-#[test]
-fn centroid_cache_is_deterministic() -> VortexResult<()> {
-    let first = compute_or_get_centroids(128, 3)?;
-    let second = compute_or_get_centroids(128, 3)?;
-
-    assert_eq!(first.as_slice(), second.as_slice());
-    Ok(())
-}
-
-#[test]
-fn encode_decode_empty_vectors() -> VortexResult<()> {
-    let session = test_session();
-    let mut ctx = session.create_execution_ctx();
-    let input = vector_array::<f32>(128, &[], Validity::NonNullable)?;
-
-    let encoded = execute_tq_encode(input, &TurboQuantConfig::default(), &mut ctx)?;
-    let decoded = execute_tq_decode(encoded, &mut ctx)?;
-
-    assert!(decoded.is_empty());
-    Ok(())
-}
-
-#[test]
-fn encode_stores_norms_and_struct_validity() -> VortexResult<()> {
-    let session = test_session();
-    let mut ctx = session.create_execution_ctx();
-    let validity = Validity::from_iter([true, false, true]);
-    let input = f32_vector_array(128, 3, 0.25, validity)?;
-
-    let config = TurboQuantConfig::try_new(3, 1, 2)?;
-    let encoded = execute_tq_encode(input, &config, &mut ctx)?;
-    let storage = turboquant_storage(encoded, &mut ctx)?;
-    let mask = storage.struct_validity().execute_mask(3, &mut ctx)?;
-    let norms: PrimitiveArray = storage
-        .unmasked_field_by_name("norms")?
-        .clone()
-        .execute(&mut ctx)?;
-    let codes: FixedSizeListArray = storage
-        .unmasked_field_by_name("codes")?
-        .clone()
-        .execute(&mut ctx)?;
-
-    assert!(mask.value(0));
-    assert!(!mask.value(1));
-    assert!(mask.value(2));
-    assert_eq!(norms.validity()?.nullability(), Nullability::Nullable);
-    assert_eq!(codes.validity()?.nullability(), Nullability::Nullable);
-
-    let norms_validity = norms.validity()?.execute_mask(3, &mut ctx)?;
-    let codes_validity = codes.validity()?.execute_mask(3, &mut ctx)?;
-    assert!(norms_validity.value(0));
-    assert!(!norms_validity.value(1));
-    assert!(norms_validity.value(2));
-    assert!(codes_validity.value(0));
-    assert!(!codes_validity.value(1));
-    assert!(codes_validity.value(2));
-
-    let codes_values: PrimitiveArray = codes.elements().clone().execute(&mut ctx)?;
-    assert!(
-        codes_values.as_slice::<u8>()[128..256]
-            .iter()
-            .all(|&code| code == 0)
-    );
-    Ok(())
-}
-
-#[test]
-fn normalize_as_l2_denorm_preserves_child_validity() -> VortexResult<()> {
-    let session = test_session();
-    let mut ctx = session.create_execution_ctx();
-    let mut values = vec![0.0f32; 3 * 128];
-    values[0] = 3.0;
-    values[1] = 4.0;
-    values[128..256].fill(13.0);
-    values[256] = 1.0;
-    let input = vector_array(128, &values, Validity::from_iter([true, false, true]))?;
-
-    let l2_denorm = tq_normalize_as_l2_denorm(input, &mut ctx)?;
-    let normalized = l2_denorm.child_at(0).clone();
-    let norms = l2_denorm.child_at(1).clone();
-
-    let normalized_ext: ExtensionArray = normalized.execute(&mut ctx)?;
-    let normalized_fsl: FixedSizeListArray =
-        normalized_ext.storage_array().clone().execute(&mut ctx)?;
-    let normalized_values: PrimitiveArray = normalized_fsl.elements().clone().execute(&mut ctx)?;
-    let norms: PrimitiveArray = norms.execute(&mut ctx)?;
-    let normalized_validity = normalized_fsl.validity()?.execute_mask(3, &mut ctx)?;
-    let norms_validity = norms.validity()?.execute_mask(3, &mut ctx)?;
-
-    assert!(normalized_validity.value(0));
-    assert!(!normalized_validity.value(1));
-    assert!(normalized_validity.value(2));
-    assert!(norms_validity.value(0));
-    assert!(!norms_validity.value(1));
-    assert!(norms_validity.value(2));
-    assert_eq!(norms.validity()?.nullability(), Nullability::Nullable);
-    assert_eq!(norms.as_slice::<f32>()[0], 5.0);
-    assert!(
-        normalized_values.as_slice::<f32>()[128..256]
-            .iter()
-            .all(|&value| value == 0.0)
-    );
-    Ok(())
-}
-
-#[test]
-fn encode_decode_preserves_nulls_and_zero_norm_rows() -> VortexResult<()> {
-    let session = test_session();
-    let mut ctx = session.create_execution_ctx();
-    let mut values = vec![0.0f32; 3 * 128];
-    values[0] = 3.0;
-    values[1] = 4.0;
-    values[256] = 1.0;
-    values[257] = -1.0;
-    let input = vector_array(128, &values, Validity::from_iter([true, true, false]))?;
-
-    let encoded = execute_tq_encode(input, &TurboQuantConfig::default(), &mut ctx)?;
-    let decoded = execute_tq_decode(encoded, &mut ctx)?;
-    let output = vector_values_f32(decoded.clone(), &mut ctx)?;
-    let validity = vector_validity(decoded, &mut ctx)?.execute_mask(3, &mut ctx)?;
-
-    assert!(validity.value(0));
-    assert!(validity.value(1));
-    assert!(!validity.value(2));
-    assert!(output[128..256].iter().all(|&v| v == 0.0));
-    Ok(())
-}
-
-#[rstest]
-#[case::f16(PType::F16)]
-#[case::f64(PType::F64)]
-fn encode_decode_supports_non_f32_inputs(#[case] ptype: PType) -> VortexResult<()> {
-    let session = test_session();
-    let mut ctx = session.create_execution_ctx();
-    let config = TurboQuantConfig::try_new(3, 42, 3)?;
-
-    match ptype {
-        PType::F16 => {
-            let values = (0..2 * 128)
-                .map(|i| half::f16::from_f32(((i % 17) as f32 - 8.0) * 0.25))
-                .collect::<Vec<_>>();
-            let input = vector_array(128, &values, Validity::NonNullable)?;
-            let encoded = execute_tq_encode(input, &config, &mut ctx)?;
-            let decoded = execute_tq_decode(encoded, &mut ctx)?;
-            let ext: ExtensionArray = decoded.execute(&mut ctx)?;
-            assert_eq!(vector_element_ptype(&ext)?, PType::F16);
-        }
-        PType::F64 => {
-            let values = (0..2 * 128)
-                .map(|i| ((i % 17) as f64 - 8.0) * 0.25)
-                .collect::<Vec<_>>();
-            let input = vector_array(128, &values, Validity::NonNullable)?;
-            let encoded = execute_tq_encode(input, &config, &mut ctx)?;
-            let decoded = execute_tq_decode(encoded, &mut ctx)?;
-            let ext: ExtensionArray = decoded.execute(&mut ctx)?;
-            assert_eq!(vector_element_ptype(&ext)?, PType::F64);
-        }
-        _ => unreachable!("test only passes f16/f64"),
-    }
-    Ok(())
-}
-
-#[test]
-fn decode_scales_by_stored_norms() -> VortexResult<()> {
-    let session = test_session();
-    let mut ctx = session.create_execution_ctx();
-    let base = f32_vector_array(128, 1, 0.5, Validity::NonNullable)?;
-    let scaled = f32_vector_array(128, 1, 1.0, Validity::NonNullable)?;
-    let config = TurboQuantConfig::try_new(2, 99, 3)?;
-
-    let base_values = vector_values_f32(
-        execute_tq_decode(execute_tq_encode(base, &config, &mut ctx)?, &mut ctx)?,
-        &mut ctx,
-    )?;
-    let scaled_values = vector_values_f32(
-        execute_tq_decode(execute_tq_encode(scaled, &config, &mut ctx)?, &mut ctx)?,
-        &mut ctx,
-    )?;
-
-    for (base, scaled) in base_values.iter().zip(scaled_values.iter()) {
-        assert!((*scaled - 2.0 * *base).abs() < 1e-5);
-    }
-    Ok(())
-}
diff --git a/vortex-turboquant/src/tests/file.rs b/vortex-turboquant/src/tests/file.rs
deleted file mode 100644
index e59b7a95c75..00000000000
--- a/vortex-turboquant/src/tests/file.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_array::IntoArray;
-use vortex_array::VortexSessionExecute;
-use vortex_array::stream::ArrayStreamExt;
-use vortex_array::validity::Validity;
-use vortex_error::VortexResult;
-use vortex_file::OpenOptionsSessionExt;
-use vortex_file::VortexWriteOptions;
-use vortex_io::runtime::BlockingRuntime;
-use vortex_io::runtime::single::SingleThreadRuntime;
-use vortex_tensor::vector::Vector;
-
-use super::execute_tq_decode_from_metadata;
-use super::execute_tq_encode;
-use super::f32_vector_array;
-use super::file_session;
-use super::vector_validity;
-use crate::TQDecode;
-use crate::TurboQuantConfig;
-use crate::vtable::tq_metadata;
-
-#[test]
-fn file_roundtrip_with_initialize_session() -> VortexResult<()> {
-    let runtime = SingleThreadRuntime::default();
-    let session = file_session(&runtime);
-    let mut ctx = session.create_execution_ctx();
-    let input = f32_vector_array(128, 2, 0.25, Validity::from_iter([true, false]))?;
-    let encoded = execute_tq_encode(input, &TurboQuantConfig::default(), &mut ctx)?;
-
-    let mut file_bytes = Vec::new();
-    VortexWriteOptions::new(session.clone())
-        .blocking(&runtime)
-        .write(&mut file_bytes, encoded.to_array_iterator())?;
-
-    let file = session.open_options().open_buffer(file_bytes)?;
-    let read = runtime.block_on(async { file.scan()?.into_array_stream()?.read_all().await })?;
-
-    let metadata = tq_metadata(read.dtype())?;
-    assert_eq!(metadata.dimensions, 128);
-    let decoded = execute_tq_decode_from_metadata(read, &mut ctx)?;
-    let validity = vector_validity(decoded, &mut ctx)?.execute_mask(2, &mut ctx)?;
-    assert!(validity.value(0));
-    assert!(!validity.value(1));
-    Ok(())
-}
-
-#[test]
-fn file_roundtrip_lazy_decode_scalar_fn_with_initialize_session() -> VortexResult<()> {
-    let runtime = SingleThreadRuntime::default();
-    let session = file_session(&runtime);
-    let mut ctx = session.create_execution_ctx();
-    let input = f32_vector_array(128, 2, 0.25, Validity::from_iter([true, false]))?;
-    let config = TurboQuantConfig::try_new(3, 42, 3)?;
-    let encoded = execute_tq_encode(input, &config, &mut ctx)?;
-    let decoded = TQDecode::try_new_array(encoded)?.into_array();
-
-    let mut file_bytes = Vec::new();
-    VortexWriteOptions::new(session.clone())
-        .blocking(&runtime)
-        .write(&mut file_bytes, decoded.to_array_iterator())?;
-
-    let file = session.open_options().open_buffer(file_bytes)?;
-    let read = runtime.block_on(async { file.scan()?.into_array_stream()?.read_all().await })?;
-
-    assert!(read.dtype().as_extension().is::<Vector>());
-
-    let validity = vector_validity(read, &mut ctx)?.execute_mask(2, &mut ctx)?;
-    assert!(validity.value(0));
-    assert!(!validity.value(1));
-    Ok(())
-}
diff --git a/vortex-turboquant/src/tests/malformed.rs b/vortex-turboquant/src/tests/malformed.rs
deleted file mode 100644
index f99f0ee5105..00000000000
--- a/vortex-turboquant/src/tests/malformed.rs
+++ /dev/null
@@ -1,189 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use rstest::rstest;
-use vortex_array::IntoArray;
-use vortex_array::VortexSessionExecute;
-use vortex_array::arrays::ExtensionArray;
-use vortex_array::arrays::FixedSizeListArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::StructArray;
-use vortex_array::dtype::FieldNames;
-use vortex_array::dtype::Nullability;
-use vortex_array::dtype::PType;
-use vortex_array::validity::Validity;
-use vortex_buffer::Buffer;
-use vortex_error::VortexResult;
-
-use super::execute_tq_decode_from_metadata;
-use super::test_session;
-use super::vector_validity;
-use crate::TurboQuant;
-use crate::TurboQuantMetadata;
-
-#[rstest]
-#[case::nullable_norms_under_nonnullable_struct(
-    Nullability::NonNullable,
-    Nullability::Nullable,
-    Nullability::NonNullable
-)]
-#[case::nullable_codes_under_nonnullable_struct(
-    Nullability::NonNullable,
-    Nullability::NonNullable,
-    Nullability::Nullable
-)]
-#[case::nonnullable_norms_under_nullable_struct(
-    Nullability::Nullable,
-    Nullability::NonNullable,
-    Nullability::Nullable
-)]
-#[case::nonnullable_codes_under_nullable_struct(
-    Nullability::Nullable,
-    Nullability::Nullable,
-    Nullability::NonNullable
-)]
-fn decode_accepts_child_nullability_that_covers_struct_validity(
-    #[case] struct_nullability: Nullability,
-    #[case] norms_nullability: Nullability,
-    #[case] codes_nullability: Nullability,
-) -> VortexResult<()> {
-    let session = test_session();
-    let mut ctx = session.create_execution_ctx();
-    let metadata = TurboQuantMetadata {
-        element_ptype: PType::F32,
-        dimensions: 128,
-        bit_width: 1,
-        seed: 42,
-        num_rounds: 3,
-    };
-    let norms =
-        PrimitiveArray::new::<f32>(Buffer::copy_from([1.0]), Validity::from(norms_nullability))
-            .into_array();
-    let codes = PrimitiveArray::new::<u8>(vec![0u8; 128], Validity::NonNullable);
-    let codes = FixedSizeListArray::try_new(
-        codes.into_array(),
-        128,
-        Validity::from(codes_nullability),
-        1,
-    )
-    .unwrap()
-    .into_array();
-    let storage = StructArray::try_new(
-        FieldNames::from(["norms", "codes"]),
-        vec![norms, codes],
-        1,
-        Validity::from(struct_nullability),
-    )
-    .unwrap();
-    let tq = ExtensionArray::try_new_from_vtable(TurboQuant, metadata, storage.into_array())
-        .unwrap()
-        .into_array();
-
-    execute_tq_decode_from_metadata(tq, &mut ctx)?;
-    Ok(())
-}
-
-#[test]
-fn decode_accepts_struct_mask_with_all_valid_children() -> VortexResult<()> {
-    let session = test_session();
-    let mut ctx = session.create_execution_ctx();
-    let metadata = TurboQuantMetadata {
-        element_ptype: PType::F32,
-        dimensions: 128,
-        bit_width: 1,
-        seed: 42,
-        num_rounds: 3,
-    };
-    let norms =
-        PrimitiveArray::new::<f32>(Buffer::copy_from([1.0, 1.0, 1.0]), Validity::NonNullable)
-            .into_array();
-    let codes = PrimitiveArray::new::<u8>(vec![0u8; 3 * 128], Validity::NonNullable);
-    let codes = FixedSizeListArray::try_new(codes.into_array(), 128, Validity::NonNullable, 3)?
-        .into_array();
-    let storage = StructArray::try_new(
-        FieldNames::from(["norms", "codes"]),
-        vec![norms, codes],
-        3,
-        Validity::from_iter([true, false, true]),
-    )?;
-    let tq = ExtensionArray::try_new_from_vtable(TurboQuant, metadata, storage.into_array())?
-        .into_array();
-
-    let decoded = execute_tq_decode_from_metadata(tq, &mut ctx)?;
-    let validity = vector_validity(decoded, &mut ctx)?.execute_mask(3, &mut ctx)?;
-    assert!(validity.value(0));
-    assert!(!validity.value(1));
-    assert!(validity.value(2));
-    Ok(())
-}
-
-#[test]
-fn decode_rejects_child_masks_that_disagree_with_struct_validity() -> VortexResult<()> {
-    let session = test_session();
-    let mut ctx = session.create_execution_ctx();
-    let metadata = TurboQuantMetadata {
-        element_ptype: PType::F32,
-        dimensions: 128,
-        bit_width: 1,
-        seed: 42,
-        num_rounds: 3,
-    };
-    let norms = PrimitiveArray::new::<f32>(
-        Buffer::copy_from([1.0, 1.0, 1.0]),
-        Validity::from_iter([true, true, false]),
-    )
-    .into_array();
-    let codes = PrimitiveArray::new::<u8>(vec![0u8; 3 * 128], Validity::NonNullable);
-    let codes = FixedSizeListArray::try_new(
-        codes.into_array(),
-        128,
-        Validity::from_iter([true, false, true]),
-        3,
-    )?
-    .into_array();
-    let storage = StructArray::try_new(
-        FieldNames::from(["norms", "codes"]),
-        vec![norms, codes],
-        3,
-        Validity::from_iter([true, false, true]),
-    )?;
-    let tq = ExtensionArray::try_new_from_vtable(TurboQuant, metadata, storage.into_array())?
-        .into_array();
-
-    assert!(execute_tq_decode_from_metadata(tq, &mut ctx).is_err());
-    Ok(())
-}
-
-#[test]
-#[should_panic(expected = "TurboQuant code exceeds centroid count")]
-fn decode_panics_on_codes_outside_centroid_table() {
-    let session = test_session();
-    let mut ctx = session.create_execution_ctx();
-    let metadata = TurboQuantMetadata {
-        element_ptype: PType::F32,
-        dimensions: 128,
-        bit_width: 1,
-        seed: 42,
-        num_rounds: 3,
-    };
-    let norms =
-        PrimitiveArray::new::<f32>(Buffer::copy_from([1.0]), Validity::NonNullable).into_array();
-    let mut codes = vec![0u8; 128];
-    codes[0] = 2;
-    let codes = PrimitiveArray::new::<u8>(codes, Validity::NonNullable);
-    let codes = FixedSizeListArray::try_new(codes.into_array(), 128, Validity::NonNullable, 1)
-        .unwrap()
-        .into_array();
-    let storage = StructArray::try_new(
-        FieldNames::from(["norms", "codes"]),
-        vec![norms, codes],
-        1,
-        Validity::NonNullable,
-    )
-    .unwrap();
-    let tq = ExtensionArray::try_new_from_vtable(TurboQuant, metadata, storage.into_array())
-        .unwrap()
-        .into_array();
-
-    drop(execute_tq_decode_from_metadata(tq, &mut ctx));
-}
diff --git a/vortex-turboquant/src/tests/metadata.rs b/vortex-turboquant/src/tests/metadata.rs
deleted file mode 100644
index e0d1042f02f..00000000000
--- a/vortex-turboquant/src/tests/metadata.rs
+++ /dev/null
@@ -1,173 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::sync::Arc;
-
-use prost::Message;
-use rstest::rstest;
-use vortex_array::dtype::DType;
-use vortex_array::dtype::FieldNames;
-use vortex_array::dtype::Nullability;
-use vortex_array::dtype::PType;
-use vortex_array::dtype::StructFields;
-use vortex_array::dtype::extension::ExtDType;
-use vortex_array::dtype::extension::ExtVTable;
-use vortex_error::VortexResult;
-use vortex_error::vortex_err;
-
-use crate::TurboQuant;
-use crate::TurboQuantMetadata;
-use crate::vector::storage::CODES_FIELD;
-use crate::vector::storage::NORMS_FIELD;
-use crate::vector::tq_padded_dim;
-
-#[derive(Clone, PartialEq, Message)]
-struct MetadataWire {
-    #[prost(enumeration = "PType", tag = "1")]
-    element_ptype: i32,
-    #[prost(uint32, tag = "2")]
-    dimensions: u32,
-    #[prost(uint32, tag = "3")]
-    bit_width: u32,
-    #[prost(uint64, tag = "4")]
-    seed: u64,
-    #[prost(uint32, tag = "5")]
-    num_rounds: u32,
-}
-
-fn tq_storage_dtype(
-    metadata: &TurboQuantMetadata,
-    row_nullability: Nullability,
-) -> VortexResult<DType> {
-    let padded_dim = u32::try_from(tq_padded_dim(metadata.dimensions)?)
-        .map_err(|_| vortex_err!("TurboQuant padded dimension does not fit u32"))?;
-    Ok(DType::Struct(
-        StructFields::new(
-            FieldNames::from([NORMS_FIELD, CODES_FIELD]),
-            vec![
-                DType::Primitive(metadata.element_ptype, row_nullability),
-                DType::FixedSizeList(
-                    Arc::new(DType::Primitive(PType::U8, Nullability::NonNullable)),
-                    padded_dim,
-                    row_nullability,
-                ),
-            ],
-        ),
-        row_nullability,
-    ))
-}
-
-#[rstest]
-#[case::f16(PType::F16)]
-#[case::f32(PType::F32)]
-#[case::f64(PType::F64)]
-fn metadata_serialization_roundtrips(#[case] element_ptype: PType) -> VortexResult<()> {
-    let metadata = TurboQuantMetadata {
-        element_ptype,
-        dimensions: 128,
-        bit_width: 4,
-        seed: 7,
-        num_rounds: 3,
-    };
-
-    let encoded = TurboQuant.serialize_metadata(&metadata)?;
-    let decoded = TurboQuant.deserialize_metadata(&encoded)?;
-
-    assert_eq!(decoded, metadata);
-    Ok(())
-}
-
-#[test]
-fn metadata_serialization_uses_ptype_discriminants() -> VortexResult<()> {
-    let metadata = TurboQuantMetadata {
-        element_ptype: PType::F32,
-        dimensions: 128,
-        bit_width: 4,
-        seed: 7,
-        num_rounds: 3,
-    };
-
-    let encoded = TurboQuant.serialize_metadata(&metadata)?;
-    let wire = MetadataWire::decode(encoded.as_slice())?;
-
-    assert_eq!(wire.element_ptype, PType::F32 as i32);
-    assert_eq!(wire.dimensions, 128);
-    Ok(())
-}
-
-#[test]
-fn metadata_display_matches_field_order() {
-    let metadata = TurboQuantMetadata {
-        element_ptype: PType::F32,
-        dimensions: 128,
-        bit_width: 4,
-        seed: 7,
-        num_rounds: 3,
-    };
-
-    assert_eq!(
-        metadata.to_string(),
-        "element_ptype: f32, dimensions: 128, bit_width: 4, seed: 7, num_rounds: 3"
-    );
-}
-
-#[test]
-fn dtype_validation_accepts_expected_storage() -> VortexResult<()> {
-    let metadata = TurboQuantMetadata {
-        element_ptype: PType::F32,
-        dimensions: 129,
-        bit_width: 2,
-        seed: 42,
-        num_rounds: 3,
-    };
-
-    ExtDType::<TurboQuant>::try_new(
-        metadata,
-        tq_storage_dtype(&metadata, Nullability::Nullable)?,
-    )?;
-    Ok(())
-}
-
-#[test]
-fn dtype_validation_accepts_nonnullable_storage() -> VortexResult<()> {
-    let metadata = TurboQuantMetadata {
-        element_ptype: PType::F32,
-        dimensions: 129,
-        bit_width: 2,
-        seed: 42,
-        num_rounds: 3,
-    };
-
-    ExtDType::<TurboQuant>::try_new(
-        metadata,
-        tq_storage_dtype(&metadata, Nullability::NonNullable)?,
-    )?;
-    Ok(())
-}
-
-#[test]
-fn dtype_validation_rejects_malformed_storage() {
-    let metadata = TurboQuantMetadata {
-        element_ptype: PType::F32,
-        dimensions: 128,
-        bit_width: 2,
-        seed: 42,
-        num_rounds: 3,
-    };
-    let storage = DType::Struct(
-        StructFields::new(
-            FieldNames::from(["norms", "codes"]),
-            vec![
-                DType::Primitive(PType::F32, Nullability::Nullable),
-                DType::FixedSizeList(
-                    DType::Primitive(PType::U8, Nullability::Nullable).into(),
-                    128,
-                    Nullability::NonNullable,
-                ),
-            ],
-        ),
-        Nullability::Nullable,
-    );
-
-    assert!(ExtDType::<TurboQuant>::try_new(metadata, storage).is_err());
-}
diff --git a/vortex-turboquant/src/tests/mod.rs b/vortex-turboquant/src/tests/mod.rs
deleted file mode 100644
index ffa1db175a7..00000000000
--- a/vortex-turboquant/src/tests/mod.rs
+++ /dev/null
@@ -1,141 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-#![cfg_attr(
-    test,
-    allow(clippy::unwrap_used, clippy::expect_used, clippy::unwrap_in_result)
-)]
-
-use vortex_array::ArrayRef;
-use vortex_array::ExecutionCtx;
-use vortex_array::IntoArray;
-use vortex_array::arrays::ExtensionArray;
-use vortex_array::arrays::FixedSizeListArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::StructArray;
-use vortex_array::arrays::extension::ExtensionArrayExt;
-use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
-use vortex_array::dtype::NativePType;
-use vortex_array::dtype::PType;
-use vortex_array::extension::EmptyMetadata;
-use vortex_array::memory::MemorySession;
-use vortex_array::session::ArraySession;
-use vortex_array::validity::Validity;
-use vortex_buffer::Buffer;
-use vortex_error::VortexResult;
-use vortex_error::vortex_err;
-use vortex_io::runtime::BlockingRuntime;
-use vortex_io::runtime::single::SingleThreadRuntime;
-use vortex_io::session::RuntimeSession;
-use vortex_io::session::RuntimeSessionExt;
-use vortex_layout::session::LayoutSession;
-use vortex_session::VortexSession;
-use vortex_tensor::vector::Vector;
-
-use crate::TQDecode;
-use crate::TQEncode;
-use crate::TurboQuantConfig;
-use crate::initialize;
-
-mod encode_decode;
-mod file;
-mod malformed;
-mod metadata;
-mod parity;
-mod scalar_fns;
-
-fn test_session() -> VortexSession {
-    let session = VortexSession::empty().with::<ArraySession>();
-    initialize(&session);
-    session
-}
-
-fn file_session(runtime: &SingleThreadRuntime) -> VortexSession {
-    let session = VortexSession::empty()
-        .with::<ArraySession>()
-        .with::<LayoutSession>()
-        .with::<MemorySession>()
-        .with::<RuntimeSession>()
-        .with_handle(runtime.handle());
-    vortex_file::register_default_encodings(&session);
-    vortex_tensor::initialize(&session);
-    initialize(&session);
-    session
-}
-
-fn vector_array<T: NativePType>(
-    dimensions: u32,
-    values: &[T],
-    validity: Validity,
-) -> VortexResult<ArrayRef> {
-    assert!(dimensions > 0, "dimensions must be > 0");
-    let row_count = values.len() / dimensions as usize;
-
-    let elements = PrimitiveArray::new::<T>(
-        values.iter().copied().collect::<Buffer<T>>(),
-        Validity::NonNullable,
-    );
-    let fsl = FixedSizeListArray::try_new(elements.into_array(), dimensions, validity, row_count)?;
-
-    Ok(ExtensionArray::try_new_from_vtable(Vector, EmptyMetadata, fsl.into_array())?.into_array())
-}
-
-fn f32_vector_array(
-    dimensions: u32,
-    rows: usize,
-    scale: f32,
-    validity: Validity,
-) -> VortexResult<ArrayRef> {
-    let values = (0..rows * dimensions as usize)
-        .map(|i| ((i % 17) as f32 - 8.0) * scale)
-        .collect::<Vec<_>>();
-    vector_array(dimensions, &values, validity)
-}
-
-fn vector_values_f32(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Vec<f32>> {
-    let ext: ExtensionArray = array.execute(ctx)?;
-    let fsl: FixedSizeListArray = ext.storage_array().clone().execute(ctx)?;
-    let elements: PrimitiveArray = fsl.elements().clone().execute(ctx)?;
-    Ok(elements.as_slice::<f32>().to_vec())
-}
-
-fn vector_validity(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Validity> {
-    let ext: ExtensionArray = array.execute(ctx)?;
-    let fsl: FixedSizeListArray = ext.storage_array().clone().execute(ctx)?;
-    fsl.validity()
-}
-
-fn vector_element_ptype(array: &ExtensionArray) -> VortexResult<PType> {
-    Ok(array
-        .storage_array()
-        .dtype()
-        .as_fixed_size_list_element_opt()
-        .ok_or_else(|| vortex_err!("expected FixedSizeList vector storage"))?
-        .as_ptype())
-}
-
-fn turboquant_storage(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<StructArray> {
-    let ext: ExtensionArray = array.execute(ctx)?;
-    ext.storage_array().clone().execute(ctx)
-}
-
-fn execute_tq_encode(
-    input: ArrayRef,
-    config: &TurboQuantConfig,
-    ctx: &mut ExecutionCtx,
-) -> VortexResult<ArrayRef> {
-    TQEncode::try_new_array(input, config)?
-        .into_array()
-        .execute(ctx)
-}
-
-fn execute_tq_decode(input: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<ArrayRef> {
-    TQDecode::try_new_array(input)?.into_array().execute(ctx)
-}
-
-fn execute_tq_decode_from_metadata(
-    input: ArrayRef,
-    ctx: &mut ExecutionCtx,
-) -> VortexResult<ArrayRef> {
-    execute_tq_decode(input, ctx)
-}
diff --git a/vortex-turboquant/src/tests/parity.rs b/vortex-turboquant/src/tests/parity.rs
deleted file mode 100644
index 4360d90849d..00000000000
--- a/vortex-turboquant/src/tests/parity.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_array::VortexSessionExecute;
-use vortex_array::validity::Validity;
-use vortex_error::VortexResult;
-use vortex_tensor::encodings::turboquant::TurboQuantConfig as OldTurboQuantConfig;
-use vortex_tensor::encodings::turboquant::turboquant_encode;
-
-use super::execute_tq_decode;
-use super::execute_tq_encode;
-use super::f32_vector_array;
-use super::test_session;
-use super::vector_values_f32;
-use crate::TurboQuantConfig;
-
-#[test]
-fn encode_decode_matches_old_turboquant_decode() -> VortexResult<()> {
-    let session = test_session();
-    let mut ctx = session.create_execution_ctx();
-    let input = f32_vector_array(128, 2, 0.125, Validity::NonNullable)?;
-    let config = TurboQuantConfig::try_new(3, 42, 3)?;
-
-    let new_encoded = execute_tq_encode(input.clone(), &config, &mut ctx)?;
-    let new_decoded = execute_tq_decode(new_encoded, &mut ctx)?;
-    let old_config = OldTurboQuantConfig {
-        bit_width: config.bit_width(),
-        seed: config.seed(),
-        num_rounds: config.num_rounds(),
-    };
-    let old_decoded = turboquant_encode(input, &old_config, &mut ctx)?.execute(&mut ctx)?;
-
-    let new_values = vector_values_f32(new_decoded, &mut ctx)?;
-    let old_values = vector_values_f32(old_decoded, &mut ctx)?;
-
-    assert_eq!(new_values, old_values);
-    Ok(())
-}
diff --git a/vortex-turboquant/src/tests/scalar_fns.rs b/vortex-turboquant/src/tests/scalar_fns.rs
deleted file mode 100644
index de125e8a5f1..00000000000
--- a/vortex-turboquant/src/tests/scalar_fns.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_array::IntoArray;
-use vortex_array::VortexSessionExecute;
-use vortex_array::extension::EmptyMetadata;
-use vortex_array::scalar_fn::ScalarFnVTable;
-use vortex_array::validity::Validity;
-use vortex_error::VortexResult;
-
-use super::f32_vector_array;
-use super::test_session;
-use super::vector_validity;
-use crate::TQDecode;
-use crate::TQEncode;
-use crate::TurboQuant;
-use crate::TurboQuantConfig;
-use crate::vtable::tq_metadata;
-
-#[test]
-fn scalar_fn_ids_and_options_roundtrip() -> VortexResult<()> {
-    let session = test_session();
-    let config = TurboQuantConfig::try_new(4, 7, 2)?;
-
-    assert_eq!(TQEncode.id().as_ref(), "vortex.turboquant.encode");
-    assert_eq!(TQDecode.id().as_ref(), "vortex.turboquant.decode");
-
-    let encode_metadata = TQEncode.serialize(&config)?.unwrap();
-    let decode_metadata = TQDecode.serialize(&EmptyMetadata)?.unwrap();
-
-    assert_eq!(TQEncode.deserialize(&encode_metadata, &session)?, config);
-    assert!(decode_metadata.is_empty());
-    assert_eq!(
-        TQDecode.deserialize(&decode_metadata, &session)?,
-        EmptyMetadata
-    );
-    Ok(())
-}
-
-#[test]
-fn scalar_fn_arrays_encode_and_decode_vectors() -> VortexResult<()> {
-    let session = test_session();
-    let mut ctx = session.create_execution_ctx();
-    let input = f32_vector_array(128, 2, 0.25, Validity::from_iter([true, false]))?;
-    let config = TurboQuantConfig::try_new(3, 42, 3)?;
-
-    let encoded_lazy = TQEncode::try_new_array(input, &config)?;
-    let encoded_metadata = tq_metadata(encoded_lazy.dtype())?;
-    assert_eq!(encoded_metadata.dimensions, 128);
-    assert_eq!(encoded_metadata.bit_width, config.bit_width());
-    assert!(encoded_lazy.dtype().as_extension().is::<TurboQuant>());
-
-    let encoded = encoded_lazy.into_array().execute(&mut ctx)?;
-    let decoded_lazy = TQDecode::try_new_array(encoded)?;
-    let decoded = decoded_lazy.into_array().execute(&mut ctx)?;
-    let validity = vector_validity(decoded, &mut ctx)?.execute_mask(2, &mut ctx)?;
-
-    assert!(validity.value(0));
-    assert!(!validity.value(1));
-    Ok(())
-}
diff --git a/vortex-turboquant/src/vector/mod.rs b/vortex-turboquant/src/vector/mod.rs
deleted file mode 100644
index f4fe8726103..00000000000
--- a/vortex-turboquant/src/vector/mod.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Vector-side helpers: normalization, quantization, and physical storage layout.
-
-pub(crate) mod normalize;
-pub(crate) mod quantize;
-pub(crate) mod storage;
-
-use vortex_error::VortexResult;
-use vortex_error::vortex_err;
-
-/// Compute the padded SORF dimension for an original vector dimension.
-///
-/// The SORF transform requires a power-of-two width, so non-power-of-two input dimensions are
-/// padded with zeros up to the next power of two. The padded dimension is stored implicitly via
-/// [`TurboQuantMetadata::dimensions`](crate::TurboQuantMetadata) plus the codes child's
-/// `FixedSizeList` width and recovered at decode time via this function. Returns an error when
-/// the next power of two overflows the input integer type.
-pub(crate) fn tq_padded_dim(dimensions: u32) -> VortexResult<usize> {
-    let padded_dim = dimensions
-        .checked_next_power_of_two()
-        .ok_or_else(|| vortex_err!("TurboQuant padded dimension overflow for {dimensions}"))?;
-
-    usize::try_from(padded_dim)
-        .map_err(|_| vortex_err!("TurboQuant padded dimension does not fit usize"))
-}
diff --git a/vortex-turboquant/src/vector/normalize.rs b/vortex-turboquant/src/vector/normalize.rs
deleted file mode 100644
index 642949eecf6..00000000000
--- a/vortex-turboquant/src/vector/normalize.rs
+++ /dev/null
@@ -1,236 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! TurboQuant-local vector normalization.
-
-// TODO(connor): Remove this comment once we delete the other version in `vortex-tensor`.
-// The tensor crate also has a `normalize_as_l2_denorm` helper, but TurboQuant needs different
-// validity semantics: a null vector is not a zero vector, so invalid rows keep their row validity
-// on both `L2Denorm` children and downstream quantization skips them.
-
-use num_traits::Float;
-use vortex_array::ArrayRef;
-use vortex_array::ExecutionCtx;
-use vortex_array::IntoArray;
-use vortex_array::arrays::ExtensionArray;
-use vortex_array::arrays::FixedSizeListArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::ScalarFnArray;
-use vortex_array::arrays::extension::ExtensionArrayExt;
-use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
-use vortex_array::dtype::NativePType;
-use vortex_array::extension::EmptyMetadata;
-use vortex_array::match_each_float_ptype;
-use vortex_array::validity::Validity;
-use vortex_buffer::BufferMut;
-use vortex_error::VortexResult;
-use vortex_error::vortex_ensure_eq;
-use vortex_error::vortex_err;
-use vortex_mask::Mask;
-use vortex_mask::MaskValues;
-use vortex_tensor::scalar_fns::l2_denorm::L2Denorm;
-use vortex_tensor::scalar_fns::l2_norm::L2Norm;
-use vortex_tensor::vector::AnyVector;
-use vortex_tensor::vector::Vector;
-
-/// Normalize a `Vector` array and wrap it with its original row norms with [`L2Denorm`].
-///
-/// This preserves input row validity on both [`L2Denorm`] children. Or in other words, validity is
-/// propagated down to the children so that TurboQuant can skip quantizing those vectors (as it does
-/// not have a good way to represent 0 vectors in its quantized domain).
-pub(crate) fn tq_normalize_as_l2_denorm(
-    input: ArrayRef,
-    ctx: &mut ExecutionCtx,
-) -> VortexResult<ScalarFnArray> {
-    let row_count = input.len();
-    let vector_metadata = input
-        .dtype()
-        .as_extension_opt()
-        .and_then(|ext_dtype| ext_dtype.metadata_opt::<AnyVector>())
-        .ok_or_else(|| vortex_err!("TurboQuant normalization expects a Vector extension array"))?;
-    let dimensions = vector_metadata.dimensions() as usize;
-    let vector_validity = input.validity()?;
-
-    // Use `L2Norm` to calculate the normals for each vector.
-    let norms: ArrayRef = L2Norm::try_new_array(input.clone(), row_count)?
-        .into_array()
-        .execute(ctx)?;
-    let primitive_norms: PrimitiveArray = norms.clone().execute(ctx)?;
-
-    let input: ExtensionArray = input.execute(ctx)?;
-    let storage: FixedSizeListArray = input.storage_array().clone().execute(ctx)?;
-    vortex_ensure_eq!(
-        storage.list_size() as usize,
-        dimensions,
-        "Vector storage dimension must be {dimensions}, got {}",
-        storage.list_size()
-    );
-    let elements: PrimitiveArray = storage.elements().clone().execute(ctx)?;
-
-    let mask = vector_validity.execute_mask(row_count, ctx)?;
-
-    let normalized = match_each_float_ptype!(elements.ptype(), |T| {
-        normalize_vectors::<T>(
-            &elements,
-            &primitive_norms,
-            &mask,
-            dimensions,
-            vector_validity.clone(),
-        )
-    })?;
-
-    // SAFETY: matches the lossy-encoding relaxation documented on
-    // [`L2Denorm::new_array_unchecked`]. Norms come from `L2Norm` over the same input, so they
-    // match the vector element type and row count. Valid nonzero rows are divided by their stored
-    // norm and are unit-norm. Valid zero-norm rows and invalid rows use physical zero placeholders;
-    // invalid rows remain guarded by row-level invalid validity.
-    unsafe { L2Denorm::new_array_unchecked(normalized, norms, row_count) }
-}
-
-fn normalize_vectors<T>(
-    elements: &PrimitiveArray,
-    norms: &PrimitiveArray,
-    mask: &Mask,
-    dimensions: usize,
-    vector_validity: Validity,
-) -> VortexResult<ArrayRef>
-where
-    T: Float + NativePType,
-{
-    let num_vectors = norms.len();
-
-    let values = elements.as_slice::<T>();
-    let norm_values = norms.as_slice::<T>();
-
-    let output_len = num_vectors
-        .checked_mul(dimensions)
-        .ok_or_else(|| vortex_err!("TurboQuant normalized vector length overflow"))?;
-    let mut output = BufferMut::<T>::with_capacity(output_len);
-
-    // The total number of pushes is always exactly `num_vectors * dimensions == output_len`
-    // across every arm below, which is the invariant the per-row `unsafe` blocks rely on.
-    match mask {
-        Mask::AllFalse(_) => {
-            // Every row is invalid: bulk-fill the output with zero placeholders.
-            //
-            // SAFETY: `output` was allocated with capacity `output_len`, and this push writes
-            // exactly `output_len` zero placeholders.
-            unsafe { output.push_n_unchecked(T::zero(), output_len) };
-        }
-        Mask::AllTrue(_) => {
-            for i in 0..num_vectors {
-                // SAFETY: `output` was allocated with capacity `output_len = num_vectors *
-                // dimensions`. This loop runs `num_vectors` times and each call pushes exactly
-                // `dimensions` elements, so capacity for `dimensions` more elements always
-                // remains.
-                unsafe { normalize_one_row::<T>(&mut output, values, norm_values, dimensions, i) };
-            }
-        }
-        Mask::Values(values_mask) => {
-            // SAFETY: `output` was allocated with capacity `output_len = num_vectors *
-            // dimensions`, which is the bound the helper requires.
-            unsafe {
-                normalize_vectors_with_mask::<T>(
-                    &mut output,
-                    values,
-                    norm_values,
-                    dimensions,
-                    num_vectors,
-                    values_mask,
-                )
-            };
-        }
-    }
-
-    // Vector elements are always non-nullable.
-    let elements = PrimitiveArray::new::<T>(output.freeze(), Validity::NonNullable);
-
-    #[expect(
-        clippy::cast_possible_truncation,
-        reason = "this initially came from a u32"
-    )]
-    let storage = FixedSizeListArray::try_new(
-        elements.into_array(),
-        dimensions as u32,
-        vector_validity,
-        num_vectors,
-    )?;
-
-    Ok(
-        ExtensionArray::try_new_from_vtable(Vector, EmptyMetadata, storage.into_array())?
-            .into_array(),
-    )
-}
-
-/// Normalize a single valid row, or push `dimensions` zero placeholders if the row's L2 norm
-/// is zero.
-///
-/// A valid vector with L2 norm zero is all zeros, so dividing through it would be undefined.
-/// Treating it the same as an invalid row preserves the original semantics.
-///
-/// # Safety
-///
-/// `output` must have capacity for at least `dimensions` more elements before this call.
-unsafe fn normalize_one_row<T>(
-    output: &mut BufferMut<T>,
-    values: &[T],
-    norm_values: &[T],
-    dimensions: usize,
-    i: usize,
-) where
-    T: Float + NativePType,
-{
-    let norm = norm_values[i];
-
-    if norm == T::zero() {
-        // SAFETY: caller guarantees capacity for `dimensions` more elements.
-        unsafe { output.push_n_unchecked(T::zero(), dimensions) };
-    } else {
-        let row_values = &values[i * dimensions..][..dimensions];
-
-        for &value in row_values {
-            // SAFETY: caller guarantees capacity for `dimensions` more elements.
-            unsafe { output.push_unchecked(value / norm) };
-        }
-    }
-}
-
-/// Walk the pre-cached run boundaries of a `Values` mask, bulk-pushing zero placeholders for
-/// invalid runs and normalizing valid runs row by row.
-///
-/// # Safety
-///
-/// `output` must have capacity for at least `num_vectors * dimensions` more elements before
-/// this call.
-unsafe fn normalize_vectors_with_mask<T>(
-    output: &mut BufferMut<T>,
-    values: &[T],
-    norm_values: &[T],
-    dimensions: usize,
-    num_vectors: usize,
-    values_mask: &MaskValues,
-) where
-    T: Float + NativePType,
-{
-    let mut cursor = 0;
-
-    for &(start, end) in values_mask.slices() {
-        if start > cursor {
-            // SAFETY: capacity invariant from caller.
-            unsafe { output.push_n_unchecked(T::zero(), (start - cursor) * dimensions) };
-        }
-
-        for i in start..end {
-            // SAFETY: capacity invariant from caller — each call pushes `dimensions` and the
-            // total number of valid rows in the mask is bounded by `num_vectors`.
-            unsafe { normalize_one_row::<T>(output, values, norm_values, dimensions, i) };
-        }
-
-        cursor = end;
-    }
-
-    if cursor < num_vectors {
-        // SAFETY: capacity invariant from caller.
-        unsafe { output.push_n_unchecked(T::zero(), (num_vectors - cursor) * dimensions) };
-    }
-}
diff --git a/vortex-turboquant/src/vector/quantize.rs b/vortex-turboquant/src/vector/quantize.rs
deleted file mode 100644
index 0861b9f6805..00000000000
--- a/vortex-turboquant/src/vector/quantize.rs
+++ /dev/null
@@ -1,181 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! Core TurboQuant quantization helpers.
-//!
-//! Quantization consumes the TurboQuant-local normalized `Vector` child. Valid rows are transformed
-//! and mapped to scalar centroid indices. Invalid rows remain in the full-length output but are
-//! skipped: their physical code bytes are placeholders guarded by the `codes` row validity.
-//!
-//! This matters because TurboQuant's scalar codebook is optimized for coordinates of transformed
-//! unit-norm vectors. The codebook does not generally contain an exact zero centroid, and a
-//! physical code byte of `0` means "centroid 0", not "zero coordinate". Null vectors therefore
-//! should not be converted to zero vectors and fed through the quantizer.
-
-use half::f16;
-use vortex_array::ExecutionCtx;
-use vortex_array::arrays::FixedSizeListArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
-use vortex_array::dtype::PType;
-use vortex_buffer::Buffer;
-use vortex_buffer::BufferMut;
-use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
-use vortex_error::vortex_err;
-use vortex_mask::Mask;
-
-use super::tq_padded_dim;
-use crate::TurboQuantConfig;
-use crate::centroids::compute_centroid_boundaries;
-use crate::centroids::compute_or_get_centroids;
-use crate::centroids::find_nearest_centroid;
-use crate::sorf::SorfMatrix;
-
-/// Shared intermediate results from the quantization loop.
-pub(crate) struct QuantizationResult {
-    pub(crate) all_indices: Buffer<u8>,
-    pub(crate) padded_dim: usize,
-}
-
-pub(crate) fn empty_quantization(padded_dim: usize) -> QuantizationResult {
-    QuantizationResult {
-        all_indices: Buffer::empty(),
-        padded_dim,
-    }
-}
-
-/// Core quantization: transform and quantize already-normalized rows.
-///
-/// # Safety
-///
-/// The input `fsl` must contain unit-norm vectors (already L2-normalized) for every valid row.
-/// Invalid rows are left row-aligned in the output but are not transformed or quantized. The
-/// transform and centroid lookup happen in f32.
-pub(crate) unsafe fn turboquant_quantize_core(
-    fsl: &FixedSizeListArray,
-    config: &TurboQuantConfig,
-    ctx: &mut ExecutionCtx,
-) -> VortexResult<QuantizationResult> {
-    let dimension = fsl.list_size();
-    let num_vectors = fsl.len();
-    let padded_dim = tq_padded_dim(dimension)?;
-
-    let sorf_transform =
-        SorfMatrix::try_new(padded_dim, config.num_rounds() as usize, config.seed())?;
-    debug_assert_eq!(sorf_transform.padded_dim(), padded_dim);
-    let padded_dim_u32 = u32::try_from(padded_dim)
-        .map_err(|_| vortex_err!("TurboQuant padded dimension does not fit u32"))?;
-
-    let elements_prim: PrimitiveArray = fsl.elements().clone().execute(ctx)?;
-    let f32_elements = cast_to_f32(elements_prim)?;
-    let validity = fsl.validity()?;
-    let mask = validity.execute_mask(num_vectors, ctx)?;
-
-    let centroids = compute_or_get_centroids(padded_dim_u32, config.bit_width())?;
-    let boundaries = compute_centroid_boundaries(&centroids);
-
-    let codes_len = num_vectors
-        .checked_mul(padded_dim)
-        .ok_or_else(|| vortex_err!("TurboQuant codes length overflow"))?;
-    let mut all_indices = BufferMut::<u8>::with_capacity(codes_len);
-
-    let mut padded = vec![0.0f32; padded_dim];
-    let mut transformed = vec![0.0f32; padded_dim];
-
-    // Pad, SORF-transform, and quantize a single row, pushing `padded_dim` codes into
-    // `all_indices`. Captures the read-only inputs and the scratch buffers so each call site
-    // only needs to pass `all_indices` and the row index.
-    //
-    // NB: `all_indices` cannot be captured here: the `Values` arm interleaves the closure call
-    // with direct `all_indices.push_n_unchecked` calls.
-    let f32_slice = f32_elements.as_slice();
-    let dimension = dimension as usize;
-    let mut quantize_row = |all_indices: &mut BufferMut<u8>, row: usize| {
-        // Reuse `padded` and `transformed` from the outer scope.
-        padded[..dimension].copy_from_slice(&f32_slice[row * dimension..][..dimension]);
-        padded[dimension..].fill(0.0);
-        sorf_transform.transform(&padded, &mut transformed);
-
-        for &value in &transformed {
-            // SAFETY: total pushes across all match arms equal `codes_len`.
-            unsafe { all_indices.push_unchecked(find_nearest_centroid(value, &boundaries)) };
-        }
-    };
-
-    // The total number of pushes is always exactly `num_vectors * padded_dim == codes_len`
-    // across every arm below, which is the invariant the per-row `unsafe` blocks rely on.
-    match &mask {
-        Mask::AllFalse(_) => {
-            // Every row is invalid: bulk-fill placeholder zero codes.
-            //
-            // SAFETY: `all_indices` was allocated with capacity `codes_len`, and this push
-            // writes exactly `codes_len` zero codes.
-            unsafe { all_indices.push_n_unchecked(0, codes_len) };
-        }
-        Mask::AllTrue(_) => {
-            for row in 0..num_vectors {
-                quantize_row(&mut all_indices, row);
-            }
-        }
-        Mask::Values(values_mask) => {
-            let mut cursor = 0;
-
-            for &(start, end) in values_mask.slices() {
-                if start > cursor {
-                    // SAFETY: total pushes across all arms equal `codes_len`.
-                    unsafe { all_indices.push_n_unchecked(0, (start - cursor) * padded_dim) };
-                }
-
-                for row in start..end {
-                    quantize_row(&mut all_indices, row);
-                }
-
-                cursor = end;
-            }
-
-            if cursor < num_vectors {
-                // SAFETY: total pushes across all arms equal `codes_len`.
-                unsafe { all_indices.push_n_unchecked(0, (num_vectors - cursor) * padded_dim) };
-            }
-        }
-    }
-
-    Ok(QuantizationResult {
-        all_indices: all_indices.freeze(),
-        padded_dim,
-    })
-}
-
-/// Cast a float [`PrimitiveArray`] to a `Buffer<f32>`.
-///
-/// Several operations in this crate (SORF transform, TurboQuant quantization) work exclusively
-/// in f32. This function handles the cast from any float ptype:
-///
-/// - f16: losslessly widened to f32.
-/// - f32: zero-copy buffer extraction.
-/// - f64: truncated to f32 precision. Values outside f32 range become +/- infinity. This is
-///   acceptable because callers of this function operate in f32 and document this constraint.
-fn cast_to_f32(prim: PrimitiveArray) -> VortexResult<Buffer<f32>> {
-    match prim.ptype() {
-        PType::F16 => Ok(prim
-            .as_slice::<f16>()
-            .iter()
-            .map(|&v| f32::from(v))
-            .collect()),
-        PType::F32 => Ok(prim.into_buffer()),
-        PType::F64 => Ok(prim
-            .as_slice::<f64>()
-            .iter()
-            .map(|&v| {
-                #[expect(
-                    clippy::cast_possible_truncation,
-                    reason = "f64 values outside f32 range become infinity, matching tensor TQ"
-                )]
-                let v = v as f32;
-                v
-            })
-            .collect()),
-        other => vortex_bail!("expected float elements, got {other:?}"),
-    }
-}
diff --git a/vortex-turboquant/src/vector/storage.rs b/vortex-turboquant/src/vector/storage.rs
deleted file mode 100644
index d1b4f06cc05..00000000000
--- a/vortex-turboquant/src/vector/storage.rs
+++ /dev/null
@@ -1,164 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! TurboQuant physical storage helpers.
-//!
-//! TurboQuant storage is row-aligned and full length:
-//!
-//! ```text
-//! Struct {
-//!     norms: Primitive<element_ptype, vector_validity>,
-//!     codes: FixedSizeList<Primitive<u8>, padded_dim, vector_validity>,
-//! }
-//! ```
-//!
-//! Row nullability is carried on the outer struct and on the `norms` and `codes` field arrays.
-//! This is deliberate duplication: null vectors remain null throughout encode/decode instead of being
-//! converted into zero vectors. The code bytes for invalid rows are physical placeholders only; the
-//! field-level validity records that those rows were not quantized.
-//!
-//! Parsing treats the outer struct validity as authoritative. Child validity may be wider than
-//! the struct validity (for example after a generic mask only updates the struct validity), but
-//! each child must be valid wherever the struct row is valid.
-
-use vortex_array::ArrayRef;
-use vortex_array::ExecutionCtx;
-use vortex_array::IntoArray;
-use vortex_array::arrays::ExtensionArray;
-use vortex_array::arrays::FixedSizeListArray;
-use vortex_array::arrays::PrimitiveArray;
-use vortex_array::arrays::StructArray;
-use vortex_array::arrays::extension::ExtensionArrayExt;
-use vortex_array::arrays::fixed_size_list::FixedSizeListArrayExt;
-use vortex_array::arrays::struct_::StructArrayExt;
-use vortex_array::dtype::FieldNames;
-use vortex_array::validity::Validity;
-use vortex_error::VortexResult;
-use vortex_error::vortex_ensure;
-use vortex_error::vortex_err;
-use vortex_mask::Mask;
-
-use super::quantize::QuantizationResult;
-use crate::vtable::TurboQuantMetadata;
-use crate::vtable::tq_metadata;
-
-/// Name of the stored row-norm child.
-pub(crate) const NORMS_FIELD: &str = "norms";
-
-/// Name of the stored quantized-code child.
-pub(crate) const CODES_FIELD: &str = "codes";
-
-/// Executed storage children of a TurboQuant extension array plus the authoritative outer
-/// struct validity. Every child is row-aligned to `len` and every child's validity covers
-/// `vector_validity`.
-pub(crate) struct TurboQuantParsedStorage {
-    /// Metadata recovered from the input extension dtype.
-    pub(crate) metadata: TurboQuantMetadata,
-    /// Authoritative row validity for the quantized vectors, taken from the outer struct.
-    pub(crate) vector_validity: Validity,
-    /// Per-row stored L2 norm of the original input vector, in `metadata.element_ptype`.
-    pub(crate) norms: PrimitiveArray,
-    /// Flat `u8` per-row centroid indices, `num_vectors * padded_dim` entries long.
-    pub(crate) codes: PrimitiveArray,
-    /// Row count.
-    pub(crate) len: usize,
-}
-
-/// Build the `codes: FixedSizeList<Primitive<u8>, padded_dim>` storage child.
-///
-/// Each row of `padded_dim` u8 codes indexes into the deterministic centroid codebook derived
-/// from `(padded_dim, bit_width)`. The centroid values are intentionally not stored in the array.
-pub(crate) fn build_codes_child(
-    num_vectors: usize,
-    quantization: QuantizationResult,
-    vector_validity: Validity,
-) -> VortexResult<ArrayRef> {
-    let codes = PrimitiveArray::new::<u8>(quantization.all_indices, Validity::NonNullable);
-    let padded_dim_u32 = u32::try_from(quantization.padded_dim)
-        .map_err(|_| vortex_err!("TurboQuant padded dimension does not fit u32"))?;
-
-    Ok(FixedSizeListArray::try_new(
-        codes.into_array(),
-        padded_dim_u32,
-        vector_validity,
-        num_vectors,
-    )?
-    .into_array())
-}
-
-/// Build the TurboQuant `Struct { norms, codes }` storage array.
-pub(crate) fn build_storage(
-    norms: ArrayRef,
-    codes: ArrayRef,
-    len: usize,
-    vector_validity: Validity,
-) -> VortexResult<ArrayRef> {
-    Ok(StructArray::try_new(
-        FieldNames::from([NORMS_FIELD, CODES_FIELD]),
-        vec![norms, codes],
-        len,
-        vector_validity,
-    )?
-    .into_array())
-}
-
-/// Parse a TurboQuant extension array into executed storage children.
-pub(crate) fn parse_storage(
-    input: ArrayRef,
-    ctx: &mut ExecutionCtx,
-) -> VortexResult<TurboQuantParsedStorage> {
-    let metadata = tq_metadata(input.dtype())?;
-    let ext: ExtensionArray = input.execute(ctx)?;
-    let storage: StructArray = ext.storage_array().clone().execute(ctx)?;
-
-    let norms: PrimitiveArray = storage
-        .unmasked_field_by_name(NORMS_FIELD)?
-        .clone()
-        .execute(ctx)?;
-
-    let codes_fsl: FixedSizeListArray = storage
-        .unmasked_field_by_name(CODES_FIELD)?
-        .clone()
-        .execute(ctx)?;
-    let codes: PrimitiveArray = codes_fsl.elements().clone().execute(ctx)?;
-
-    let len = storage.len();
-    let struct_validity = storage.struct_validity();
-    let norms_validity = norms.validity()?;
-    let codes_validity = codes_fsl.validity()?;
-
-    let struct_mask = struct_validity.execute_mask(len, ctx)?;
-    let norms_mask = norms_validity.execute_mask(len, ctx)?;
-    let codes_mask = codes_validity.execute_mask(len, ctx)?;
-    validate_child_validity_covers_struct(&struct_mask, &norms_mask, &codes_mask)?;
-
-    Ok(TurboQuantParsedStorage {
-        metadata,
-        vector_validity: struct_validity,
-        norms,
-        codes,
-        len,
-    })
-}
-
-/// Validate that both child masks cover the struct mask: every row that the struct considers
-/// valid must also be valid in the `norms` and `codes` children.
-///
-/// `struct_mask & !child_mask` selects rows where the struct is valid but the child is not. If
-/// no such row exists, the child covers the struct. [`Mask::bitand_not`] is variant-specialized,
-/// so this short-circuits in `O(1)` when either mask is `AllTrue` or `AllFalse`.
-fn validate_child_validity_covers_struct(
-    struct_mask: &Mask,
-    norms_mask: &Mask,
-    codes_mask: &Mask,
-) -> VortexResult<()> {
-    vortex_ensure!(
-        struct_mask.clone().bitand_not(norms_mask).all_false(),
-        "TurboQuant {NORMS_FIELD} row validity must cover storage validity"
-    );
-    vortex_ensure!(
-        struct_mask.clone().bitand_not(codes_mask).all_false(),
-        "TurboQuant {CODES_FIELD} row validity must cover storage validity"
-    );
-    Ok(())
-}
diff --git a/vortex-turboquant/src/vtable.rs b/vortex-turboquant/src/vtable.rs
deleted file mode 100644
index 854bcee6c70..00000000000
--- a/vortex-turboquant/src/vtable.rs
+++ /dev/null
@@ -1,241 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::fmt;
-use std::sync::Arc;
-
-use prost::Message;
-use vortex_array::dtype::DType;
-use vortex_array::dtype::FieldNames;
-use vortex_array::dtype::Nullability;
-use vortex_array::dtype::PType;
-use vortex_array::dtype::StructFields;
-use vortex_array::dtype::extension::ExtDType;
-use vortex_array::dtype::extension::ExtId;
-use vortex_array::dtype::extension::ExtVTable;
-use vortex_array::scalar::ScalarValue;
-use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
-use vortex_error::vortex_ensure;
-use vortex_error::vortex_ensure_eq;
-use vortex_error::vortex_err;
-
-use crate::TurboQuantConfig;
-use crate::config::MIN_DIMENSION;
-use crate::vector::storage::CODES_FIELD;
-use crate::vector::storage::NORMS_FIELD;
-use crate::vector::tq_padded_dim;
-
-/// TurboQuant logical extension type. Per-array configuration lives in [`TurboQuantMetadata`].
-#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
-pub struct TurboQuant;
-
-/// Serialized metadata for a TurboQuant extension array. The fields together suffice to
-/// reconstruct the SORF transform and centroid codebook at decode time.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub struct TurboQuantMetadata {
-    /// Original vector element ptype and stored row-norm ptype. Restricted to `f16` / `f32` /
-    /// `f64`.
-    pub element_ptype: PType,
-    /// Original vector dimension before SORF padding to the next power of two.
-    pub dimensions: u32,
-    /// Bits per coordinate in the scalar quantizer codebook (`1..=8`).
-    pub bit_width: u8,
-    /// Seed used to derive the deterministic SORF transform.
-    pub seed: u64,
-    /// Number of sign-diagonal plus Walsh-Hadamard rounds in the SORF transform.
-    pub num_rounds: u8,
-}
-
-impl ExtVTable for TurboQuant {
-    type Metadata = TurboQuantMetadata;
-    type NativeValue<'a> = &'a ScalarValue;
-
-    fn id(&self) -> ExtId {
-        ExtId::new("vortex.turboquant")
-    }
-
-    fn serialize_metadata(&self, metadata: &Self::Metadata) -> VortexResult<Vec<u8>> {
-        validate_tq_metadata(metadata)?;
-
-        let proto = TurboQuantMetadataProto {
-            element_ptype: metadata.element_ptype as i32,
-            dimensions: metadata.dimensions,
-            bit_width: u32::from(metadata.bit_width),
-            seed: metadata.seed,
-            num_rounds: u32::from(metadata.num_rounds),
-        };
-
-        Ok(proto.encode_to_vec())
-    }
-
-    fn deserialize_metadata(&self, metadata: &[u8]) -> VortexResult<Self::Metadata> {
-        let proto = TurboQuantMetadataProto::decode(metadata)
-            .map_err(|e| vortex_err!("Failed to decode TurboQuantMetadata: {e}"))?;
-        let bit_width = u8::try_from(proto.bit_width)
-            .map_err(|_| vortex_err!("TurboQuant bit_width does not fit u8"))?;
-        let num_rounds = u8::try_from(proto.num_rounds)
-            .map_err(|_| vortex_err!("TurboQuant num_rounds does not fit u8"))?;
-        let element_ptype = PType::try_from(proto.element_ptype).map_err(|e| {
-            vortex_err!(
-                "invalid TurboQuant metadata element_ptype code {}: {e}",
-                proto.element_ptype
-            )
-        })?;
-
-        let metadata = TurboQuantMetadata {
-            element_ptype,
-            dimensions: proto.dimensions,
-            bit_width,
-            seed: proto.seed,
-            num_rounds,
-        };
-        validate_tq_metadata(&metadata)?;
-
-        Ok(metadata)
-    }
-
-    fn validate_dtype(ext_dtype: &ExtDType<Self>) -> VortexResult<()> {
-        validate_tq_metadata(ext_dtype.metadata())?;
-        validate_tq_storage_dtype(ext_dtype.metadata(), ext_dtype.storage_dtype())
-    }
-
-    fn unpack_native<'a>(
-        _ext_dtype: &'a ExtDType<Self>,
-        storage_value: &'a ScalarValue,
-    ) -> VortexResult<Self::NativeValue<'a>> {
-        Ok(storage_value)
-    }
-}
-
-/// Wire-format representation of [`TurboQuantMetadata`]. Field tags MUST NOT change once
-/// shipped; new fields must use unused tags and remain optional.
-#[derive(Clone, PartialEq, Message)]
-struct TurboQuantMetadataProto {
-    #[prost(enumeration = "PType", tag = "1")]
-    element_ptype: i32,
-    #[prost(uint32, tag = "2")]
-    dimensions: u32,
-    #[prost(uint32, tag = "3")]
-    bit_width: u32,
-    #[prost(uint64, tag = "4")]
-    seed: u64,
-    #[prost(uint32, tag = "5")]
-    num_rounds: u32,
-}
-
-/// Extract TurboQuant metadata from a dtype.
-///
-/// Returns an error when the dtype is not the TurboQuant extension type.
-pub(crate) fn tq_metadata(dtype: &DType) -> VortexResult<TurboQuantMetadata> {
-    let ext_dtype = dtype
-        .as_extension_opt()
-        .ok_or_else(|| vortex_err!("expected a TurboQuant extension array, got {dtype}"))?;
-
-    let metadata = ext_dtype
-        .metadata_opt::<TurboQuant>()
-        .ok_or_else(|| vortex_err!("expected a TurboQuant extension array, got {dtype}"))?;
-
-    Ok(*metadata)
-}
-
-pub(crate) fn tq_storage_dtype(
-    metadata: &TurboQuantMetadata,
-    row_nullability: Nullability,
-) -> VortexResult<DType> {
-    let padded_dim = u32::try_from(tq_padded_dim(metadata.dimensions)?)
-        .map_err(|_| vortex_err!("TurboQuant padded dimension does not fit u32"))?;
-
-    Ok(DType::Struct(
-        StructFields::new(
-            FieldNames::from([NORMS_FIELD, CODES_FIELD]),
-            vec![
-                DType::Primitive(metadata.element_ptype, row_nullability),
-                DType::FixedSizeList(
-                    Arc::new(DType::Primitive(PType::U8, Nullability::NonNullable)),
-                    padded_dim,
-                    row_nullability,
-                ),
-            ],
-        ),
-        row_nullability,
-    ))
-}
-
-/// Validate [`TurboQuantMetadata`] invariants. Called on both serialize and deserialize so a
-/// corrupted on-disk metadata block errors out rather than decoding into nonsense.
-fn validate_tq_metadata(metadata: &TurboQuantMetadata) -> VortexResult<()> {
-    vortex_ensure!(
-        metadata.dimensions >= MIN_DIMENSION,
-        "TurboQuant dimensions must be >= {MIN_DIMENSION}, got {}",
-        metadata.dimensions
-    );
-    vortex_ensure!(
-        metadata.element_ptype.is_float(),
-        "TurboQuant element_ptype must be a float, got {:?}",
-        metadata.element_ptype
-    );
-
-    tq_padded_dim(metadata.dimensions)?;
-
-    TurboQuantConfig::try_new(metadata.bit_width, metadata.seed, metadata.num_rounds).map(|_| ())
-}
-
-/// Validate that `dtype` matches the storage shape produced by [`tq_storage_dtype`] for
-/// `metadata`. Called from [`TurboQuant::validate_dtype`].
-fn validate_tq_storage_dtype(metadata: &TurboQuantMetadata, dtype: &DType) -> VortexResult<()> {
-    let DType::Struct(fields, _) = dtype else {
-        vortex_bail!("TurboQuant storage dtype must be a Struct, got {dtype}");
-    };
-    let expected_names = FieldNames::from([NORMS_FIELD, CODES_FIELD]);
-    vortex_ensure_eq!(
-        fields.names(),
-        &expected_names,
-        "TurboQuant storage fields must be {expected_names}, got {}",
-        fields.names()
-    );
-
-    let Some(norms_dtype) = fields.field(NORMS_FIELD) else {
-        vortex_bail!("TurboQuant storage missing {NORMS_FIELD} field");
-    };
-    let DType::Primitive(norms_ptype, _) = norms_dtype else {
-        vortex_bail!("TurboQuant {NORMS_FIELD} field must be primitive, got {norms_dtype}");
-    };
-    vortex_ensure_eq!(
-        norms_ptype,
-        metadata.element_ptype,
-        "TurboQuant {NORMS_FIELD} ptype must be {}, got {norms_ptype}",
-        metadata.element_ptype
-    );
-
-    let Some(codes_dtype) = fields.field(CODES_FIELD) else {
-        vortex_bail!("TurboQuant storage missing {CODES_FIELD} field");
-    };
-    let DType::FixedSizeList(element_dtype, list_size, _) = codes_dtype else {
-        vortex_bail!("TurboQuant {CODES_FIELD} field must be fixed-size-list, got {codes_dtype}");
-    };
-    let padded_dim = u32::try_from(tq_padded_dim(metadata.dimensions)?)
-        .map_err(|_| vortex_err!("TurboQuant padded dimension does not fit u32"))?;
-    vortex_ensure_eq!(
-        list_size,
-        padded_dim,
-        "TurboQuant {CODES_FIELD} list size must be {padded_dim}, got {list_size}"
-    );
-    vortex_ensure_eq!(
-        element_dtype.as_ref(),
-        &DType::Primitive(PType::U8, Nullability::NonNullable),
-        "TurboQuant {CODES_FIELD} elements must be non-nullable u8, got {element_dtype}"
-    );
-
-    Ok(())
-}
-
-impl fmt::Display for TurboQuantMetadata {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "element_ptype: {}, dimensions: {}, bit_width: {}, seed: {}, num_rounds: {}",
-            self.element_ptype, self.dimensions, self.bit_width, self.seed, self.num_rounds
-        )
-    }
-}
diff --git a/vortex-utils/Cargo.toml b/vortex-utils/Cargo.toml
index 66b2576f98d..ca6c639ec0d 100644
--- a/vortex-utils/Cargo.toml
+++ b/vortex-utils/Cargo.toml
@@ -16,7 +16,6 @@ version = { workspace = true }
 [dependencies]
 dashmap = { workspace = true, optional = true }
 hashbrown = { workspace = true }
-parking_lot = { workspace = true, optional = true }
 vortex-error = { workspace = true }
 
 [lints]
diff --git a/vortex-web/crate/src/wasm.rs b/vortex-web/crate/src/wasm.rs
index 05e328e5341..f1bb4df791e 100644
--- a/vortex-web/crate/src/wasm.rs
+++ b/vortex-web/crate/src/wasm.rs
@@ -293,7 +293,12 @@ impl VortexFileHandle {
 
         let segment_source = self.vxf.segment_source();
         let reader = layout
-            .new_reader(node_id.into(), segment_source, &self.session)
+            .new_reader(
+                node_id.into(),
+                segment_source,
+                &self.session,
+                &Default::default(),
+            )
             .map_err(|e| JsValue::from_str(&e.to_string()))?;
 
         let stream = ScanBuilder::new(self.session.clone(), reader)
diff --git a/vortex-web/package-lock.json b/vortex-web/package-lock.json
index 5a244098015..c7f414b27d3 100644
--- a/vortex-web/package-lock.json
+++ b/vortex-web/package-lock.json
@@ -46,13 +46,13 @@
       "license": "MIT"
     },
     "node_modules/@babel/code-frame": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz",
-      "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz",
+      "integrity": "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-validator-identifier": "^7.28.5",
+        "@babel/helper-validator-identifier": "^7.29.7",
         "js-tokens": "^4.0.0",
         "picocolors": "^1.1.1"
       },
@@ -61,9 +61,9 @@
       }
     },
     "node_modules/@babel/compat-data": {
-      "version": "7.29.3",
-      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.3.tgz",
-      "integrity": "sha512-LIVqM46zQWZhj17qA8wb4nW/ixr2y1Nw+r1etiAWgRM6U1IqP+LNhL1yg440jYZR72jCWcWbLWzIosH+uP1fqg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.7.tgz",
+      "integrity": "sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -71,21 +71,21 @@
       }
     },
     "node_modules/@babel/core": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz",
-      "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.7.tgz",
+      "integrity": "sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^7.29.0",
-        "@babel/generator": "^7.29.0",
-        "@babel/helper-compilation-targets": "^7.28.6",
-        "@babel/helper-module-transforms": "^7.28.6",
-        "@babel/helpers": "^7.28.6",
-        "@babel/parser": "^7.29.0",
-        "@babel/template": "^7.28.6",
-        "@babel/traverse": "^7.29.0",
-        "@babel/types": "^7.29.0",
+        "@babel/code-frame": "^7.29.7",
+        "@babel/generator": "^7.29.7",
+        "@babel/helper-compilation-targets": "^7.29.7",
+        "@babel/helper-module-transforms": "^7.29.7",
+        "@babel/helpers": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/template": "^7.29.7",
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7",
         "@jridgewell/remapping": "^2.3.5",
         "convert-source-map": "^2.0.0",
         "debug": "^4.1.0",
@@ -102,14 +102,14 @@
       }
     },
     "node_modules/@babel/generator": {
-      "version": "7.29.1",
-      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz",
-      "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.7.tgz",
+      "integrity": "sha512-DkXD5OJQaAQIdZ1bt3UZdEnHAn9Imd3IVBdX03UFe+ony9Ojw5pzr9YVKGDY1jt+Gcn/FnGkNf8r+Vj5NOJWtQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/parser": "^7.29.0",
-        "@babel/types": "^7.29.0",
+        "@babel/parser": "^7.29.7",
+        "@babel/types": "^7.29.7",
         "@jridgewell/gen-mapping": "^0.3.12",
         "@jridgewell/trace-mapping": "^0.3.28",
         "jsesc": "^3.0.2"
@@ -119,14 +119,14 @@
       }
     },
     "node_modules/@babel/helper-compilation-targets": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz",
-      "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.29.7.tgz",
+      "integrity": "sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/compat-data": "^7.28.6",
-        "@babel/helper-validator-option": "^7.27.1",
+        "@babel/compat-data": "^7.29.7",
+        "@babel/helper-validator-option": "^7.29.7",
         "browserslist": "^4.24.0",
         "lru-cache": "^5.1.1",
         "semver": "^6.3.1"
@@ -136,9 +136,9 @@
       }
     },
     "node_modules/@babel/helper-globals": {
-      "version": "7.28.0",
-      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
-      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.29.7.tgz",
+      "integrity": "sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -146,29 +146,29 @@
       }
     },
     "node_modules/@babel/helper-module-imports": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz",
-      "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.29.7.tgz",
+      "integrity": "sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/traverse": "^7.28.6",
-        "@babel/types": "^7.28.6"
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-module-transforms": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz",
-      "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.29.7.tgz",
+      "integrity": "sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-module-imports": "^7.28.6",
-        "@babel/helper-validator-identifier": "^7.28.5",
-        "@babel/traverse": "^7.28.6"
+        "@babel/helper-module-imports": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -178,9 +178,9 @@
       }
     },
     "node_modules/@babel/helper-string-parser": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
-      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz",
+      "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -188,9 +188,9 @@
       }
     },
     "node_modules/@babel/helper-validator-identifier": {
-      "version": "7.28.5",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
-      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz",
+      "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -198,9 +198,9 @@
       }
     },
     "node_modules/@babel/helper-validator-option": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
-      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.29.7.tgz",
+      "integrity": "sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -208,27 +208,27 @@
       }
     },
     "node_modules/@babel/helpers": {
-      "version": "7.29.2",
-      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.2.tgz",
-      "integrity": "sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.7.tgz",
+      "integrity": "sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/template": "^7.28.6",
-        "@babel/types": "^7.29.0"
+        "@babel/template": "^7.29.7",
+        "@babel/types": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/parser": {
-      "version": "7.29.3",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.3.tgz",
-      "integrity": "sha512-b3ctpQwp+PROvU/cttc4OYl4MzfJUWy6FZg+PMXfzmt/+39iHVF0sDfqay8TQM3JA2EUOyKcFZt75jWriQijsA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.7.tgz",
+      "integrity": "sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/types": "^7.29.0"
+        "@babel/types": "^7.29.7"
       },
       "bin": {
         "parser": "bin/babel-parser.js"
@@ -238,9 +238,9 @@
       }
     },
     "node_modules/@babel/runtime": {
-      "version": "7.29.2",
-      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.2.tgz",
-      "integrity": "sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.7.tgz",
+      "integrity": "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==",
       "dev": true,
       "license": "MIT",
       "peer": true,
@@ -249,33 +249,33 @@
       }
     },
     "node_modules/@babel/template": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz",
-      "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz",
+      "integrity": "sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^7.28.6",
-        "@babel/parser": "^7.28.6",
-        "@babel/types": "^7.28.6"
+        "@babel/code-frame": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/types": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/traverse": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz",
-      "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.7.tgz",
+      "integrity": "sha512-EhlfNQtZ+NK22w5BM61ciuiq1m58ed33Wr1Xan//ZRTy6hgjnwyCffRYwzsGXdASJSUJ1guZILsErh1eQcl+zw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^7.29.0",
-        "@babel/generator": "^7.29.0",
-        "@babel/helper-globals": "^7.28.0",
-        "@babel/parser": "^7.29.0",
-        "@babel/template": "^7.28.6",
-        "@babel/types": "^7.29.0",
+        "@babel/code-frame": "^7.29.7",
+        "@babel/generator": "^7.29.7",
+        "@babel/helper-globals": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/template": "^7.29.7",
+        "@babel/types": "^7.29.7",
         "debug": "^4.3.1"
       },
       "engines": {
@@ -283,14 +283,14 @@
       }
     },
     "node_modules/@babel/types": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz",
-      "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.7.tgz",
+      "integrity": "sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-string-parser": "^7.27.1",
-        "@babel/helper-validator-identifier": "^7.28.5"
+        "@babel/helper-string-parser": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1450,9 +1450,9 @@
       }
     },
     "node_modules/@oxc-resolver/binding-android-arm-eabi": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-android-arm-eabi/-/binding-android-arm-eabi-11.19.1.tgz",
-      "integrity": "sha512-aUs47y+xyXHUKlbhqHUjBABjvycq6YSD7bpxSW7vplUmdzAlJ93yXY6ZR0c1o1x5A/QKbENCvs3+NlY8IpIVzg==",
+      "version": "11.20.0",
+      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-android-arm-eabi/-/binding-android-arm-eabi-11.20.0.tgz",
+      "integrity": "sha512-IjfWOXRgJFNdORDl+Uf1aibNgZY2guOD3zmOhx1BGVb/MIiqlFTdmjpQNplSN58lhWehnX4UNqC3QwpUo8pjJg==",
       "cpu": [
         "arm"
       ],
@@ -1464,9 +1464,9 @@
       ]
     },
     "node_modules/@oxc-resolver/binding-android-arm64": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-android-arm64/-/binding-android-arm64-11.19.1.tgz",
-      "integrity": "sha512-oolbkRX+m7Pq2LNjr/kKgYeC7bRDMVTWPgxBGMjSpZi/+UskVo4jsMU3MLheZV55jL6c3rNelPl4oD60ggYmqA==",
+      "version": "11.20.0",
+      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-android-arm64/-/binding-android-arm64-11.20.0.tgz",
+      "integrity": "sha512-QqslZAuFQG8Q9xm7JuIn8JUbvywhSBMVhuQHtYW+auirZJloS41oxUUaBXk7uUhZJgp44c5zQLeVvmFaDQB+2Q==",
       "cpu": [
         "arm64"
       ],
@@ -1478,9 +1478,9 @@
       ]
     },
     "node_modules/@oxc-resolver/binding-darwin-arm64": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-darwin-arm64/-/binding-darwin-arm64-11.19.1.tgz",
-      "integrity": "sha512-nUC6d2i3R5B12sUW4O646qD5cnMXf2oBGPLIIeaRfU9doJRORAbE2SGv4eW6rMqhD+G7nf2Y8TTJTLiiO3Q/dQ==",
+      "version": "11.20.0",
+      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-darwin-arm64/-/binding-darwin-arm64-11.20.0.tgz",
+      "integrity": "sha512-MUcavykj2ewlR+kc5arpg4tC2RvzJkUxWtNv74pf7lcNk00GpIpN43vXMj+j6r4eMmfZhlb8hueKoIb8e9kAGQ==",
       "cpu": [
         "arm64"
       ],
@@ -1492,9 +1492,9 @@
       ]
     },
     "node_modules/@oxc-resolver/binding-darwin-x64": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-darwin-x64/-/binding-darwin-x64-11.19.1.tgz",
-      "integrity": "sha512-cV50vE5+uAgNcFa3QY1JOeKDSkM/9ReIcc/9wn4TavhW/itkDGrXhw9jaKnkQnGbjJ198Yh5nbX/Gr2mr4Z5jQ==",
+      "version": "11.20.0",
+      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-darwin-x64/-/binding-darwin-x64-11.20.0.tgz",
+      "integrity": "sha512-BGB16nRUK5Etiv//ihPyzj8Lj1px0mhh4YIfe0FDf045ywknfSm0GEbiRESpr6Q4K82AvnyaRIhhluHByvS4bg==",
       "cpu": [
         "x64"
       ],
@@ -1506,9 +1506,9 @@
       ]
     },
     "node_modules/@oxc-resolver/binding-freebsd-x64": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-freebsd-x64/-/binding-freebsd-x64-11.19.1.tgz",
-      "integrity": "sha512-xZOQiYGFxtk48PBKff+Zwoym7ScPAIVp4c14lfLxizO2LTTTJe5sx9vQNGrBymrf/vatSPNMD4FgsaaRigPkqw==",
+      "version": "11.20.0",
+      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-freebsd-x64/-/binding-freebsd-x64-11.20.0.tgz",
+      "integrity": "sha512-JZgtePaqj3qmD5XFHJaSLWzHRxQu0LaPkdoM1KJXYADvAaa83ijXHclV3ej3CueeW0wxfIAbGCZVP45J0CA7uQ==",
       "cpu": [
         "x64"
       ],
@@ -1520,9 +1520,9 @@
       ]
     },
     "node_modules/@oxc-resolver/binding-linux-arm-gnueabihf": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-11.19.1.tgz",
-      "integrity": "sha512-lXZYWAC6kaGe/ky2su94e9jN9t6M0/6c+GrSlCqL//XO1cxi5lpAhnJYdyrKfm0ZEr/c7RNyAx3P7FSBcBd5+A==",
+      "version": "11.20.0",
+      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-11.20.0.tgz",
+      "integrity": "sha512-hOQ/p3ry3v3SchUBXicrrnszaI/UmYzM4wtS4RGfwgVUX7a+HbyQSzJ5aOzu+o6XZkFkS3ZXN4PZAzhOb77OSg==",
       "cpu": [
         "arm"
       ],
@@ -1534,9 +1534,9 @@
       ]
     },
     "node_modules/@oxc-resolver/binding-linux-arm-musleabihf": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-arm-musleabihf/-/binding-linux-arm-musleabihf-11.19.1.tgz",
-      "integrity": "sha512-veG1kKsuK5+t2IsO9q0DErYVSw2azvCVvWHnfTOS73WE0STdLLB7Q1bB9WR+yHPQM76ASkFyRbogWo1GR1+WbQ==",
+      "version": "11.20.0",
+      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-arm-musleabihf/-/binding-linux-arm-musleabihf-11.20.0.tgz",
+      "integrity": "sha512-2ArPksaw0AqeuGBfoS715VF+JvJQAhD2niWgjE5hVO+L+nAfikVQopvngCMX9x4BD8itWoQ3dnikrQyl5Ho5Jg==",
       "cpu": [
         "arm"
       ],
@@ -1548,9 +1548,9 @@
       ]
     },
     "node_modules/@oxc-resolver/binding-linux-arm64-gnu": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-11.19.1.tgz",
-      "integrity": "sha512-heV2+jmXyYnUrpUXSPugqWDRpnsQcDm2AX4wzTuvgdlZfoNYO0O3W2AVpJYaDn9AG4JdM6Kxom8+foE7/BcSig==",
+      "version": "11.20.0",
+      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-11.20.0.tgz",
+      "integrity": "sha512-0bJnmYFp62JdZ4nVMDUZ/C58BCZOCcqgKtnUlp7L9Ojf/czIN+3j72YlLPeWLkzlr6SlYvIQA4SGV/HyO0d+qg==",
       "cpu": [
         "arm64"
       ],
@@ -1565,9 +1565,9 @@
       ]
     },
     "node_modules/@oxc-resolver/binding-linux-arm64-musl": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-arm64-musl/-/binding-linux-arm64-musl-11.19.1.tgz",
-      "integrity": "sha512-jvo2Pjs1c9KPxMuMPIeQsgu0mOJF9rEb3y3TdpsrqwxRM+AN6/nDDwv45n5ZrUnQMsdBy5gIabioMKnQfWo9ew==",
+      "version": "11.20.0",
+      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-arm64-musl/-/binding-linux-arm64-musl-11.20.0.tgz",
+      "integrity": "sha512-wKHHzPKZo7Ufhv/Bt6yxT7FOgnIgW4gwXcJUipkShGp68W3wGVqvr1Sr0fY65lN0Oy6y41+g2kIDvkgZaMMUkw==",
       "cpu": [
         "arm64"
       ],
@@ -1582,9 +1582,9 @@
       ]
     },
     "node_modules/@oxc-resolver/binding-linux-ppc64-gnu": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-11.19.1.tgz",
-      "integrity": "sha512-vLmdNxWCdN7Uo5suays6A/+ywBby2PWBBPXctWPg5V0+eVuzsJxgAn6MMB4mPlshskYbppjpN2Zg83ArHze9gQ==",
+      "version": "11.20.0",
+      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-11.20.0.tgz",
+      "integrity": "sha512-RN8goF7Ie0B79L4i4G6OeBocTgSC56vJbQ65VJje+oXnldVpLnOU7j/AQ/dP94TcCS+Yh6WG8u3Qt4ETteXFNQ==",
       "cpu": [
         "ppc64"
       ],
@@ -1599,9 +1599,9 @@
       ]
     },
     "node_modules/@oxc-resolver/binding-linux-riscv64-gnu": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-riscv64-gnu/-/binding-linux-riscv64-gnu-11.19.1.tgz",
-      "integrity": "sha512-/b+WgR+VTSBxzgOhDO7TlMXC1ufPIMR6Vj1zN+/x+MnyXGW7prTLzU9eW85Aj7Th7CCEG9ArCbTeqxCzFWdg2w==",
+      "version": "11.20.0",
+      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-riscv64-gnu/-/binding-linux-riscv64-gnu-11.20.0.tgz",
+      "integrity": "sha512-5l1yU6/xQEqLZRzxqmMxJfWPslpwCmBsdDGaBvABPehxquCXDC7dd7oraNdKSJUMDXSM7VvVj8H2D2FTjU7oWw==",
       "cpu": [
         "riscv64"
       ],
@@ -1616,9 +1616,9 @@
       ]
     },
     "node_modules/@oxc-resolver/binding-linux-riscv64-musl": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-riscv64-musl/-/binding-linux-riscv64-musl-11.19.1.tgz",
-      "integrity": "sha512-YlRdeWb9j42p29ROh+h4eg/OQ3dTJlpHSa+84pUM9+p6i3djtPz1q55yLJhgW9XfDch7FN1pQ/Vd6YP+xfRIuw==",
+      "version": "11.20.0",
+      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-riscv64-musl/-/binding-linux-riscv64-musl-11.20.0.tgz",
+      "integrity": "sha512-xHEvkbgz6UC+A3JOyDQy76LkUaxsNSfIr3/GV8slwZsnuooJiIB34gzJfsyvR4JdCYNUUPsRJc/w/oWkODu+hg==",
       "cpu": [
         "riscv64"
       ],
@@ -1633,9 +1633,9 @@
       ]
     },
     "node_modules/@oxc-resolver/binding-linux-s390x-gnu": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-11.19.1.tgz",
-      "integrity": "sha512-EDpafVOQWF8/MJynsjOGFThcqhRHy417sRyLfQmeiamJ8qVhSKAn2Dn2VVKUGCjVB9C46VGjhNo7nOPUi1x6uA==",
+      "version": "11.20.0",
+      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-11.20.0.tgz",
+      "integrity": "sha512-aWPDUUmSeyHvlW+SoEUd+JIJsQhVhu6a5tBpDRMu058naPAchTgAVGCFy35zjbnFlt0i8hLWziff6HX0D3LU4g==",
       "cpu": [
         "s390x"
       ],
@@ -1650,9 +1650,9 @@
       ]
     },
     "node_modules/@oxc-resolver/binding-linux-x64-gnu": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-x64-gnu/-/binding-linux-x64-gnu-11.19.1.tgz",
-      "integrity": "sha512-NxjZe+rqWhr+RT8/Ik+5ptA3oz7tUw361Wa5RWQXKnfqwSSHdHyrw6IdcTfYuml9dM856AlKWZIUXDmA9kkiBQ==",
+      "version": "11.20.0",
+      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-x64-gnu/-/binding-linux-x64-gnu-11.20.0.tgz",
+      "integrity": "sha512-x2YeSimvhJjKLVD8KSu8f/rqU1potcdEMkApIPJqjZWN7c2Fpt4g2X32WDg1p+XDAmyT7nuQGe0vnhvXeLbH+g==",
       "cpu": [
         "x64"
       ],
@@ -1667,9 +1667,9 @@
       ]
     },
     "node_modules/@oxc-resolver/binding-linux-x64-musl": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-x64-musl/-/binding-linux-x64-musl-11.19.1.tgz",
-      "integrity": "sha512-cM/hQwsO3ReJg5kR+SpI69DMfvNCp+A/eVR4b4YClE5bVZwz8rh2Nh05InhwI5HR/9cArbEkzMjcKgTHS6UaNw==",
+      "version": "11.20.0",
+      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-x64-musl/-/binding-linux-x64-musl-11.20.0.tgz",
+      "integrity": "sha512-kcRLEIxpZefeYfLChjpgFf3ilBzRDZ+yobMrpRsQlSrxuFGtm3U6PMU7AaEpMqo3NfDGVyJJseAjnRLzMFHjwQ==",
       "cpu": [
         "x64"
       ],
@@ -1684,9 +1684,9 @@
       ]
     },
     "node_modules/@oxc-resolver/binding-openharmony-arm64": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-openharmony-arm64/-/binding-openharmony-arm64-11.19.1.tgz",
-      "integrity": "sha512-QF080IowFB0+9Rh6RcD19bdgh49BpQHUW5TajG1qvWHvmrQznTZZjYlgE2ltLXyKY+qs4F/v5xuX1XS7Is+3qA==",
+      "version": "11.20.0",
+      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-openharmony-arm64/-/binding-openharmony-arm64-11.20.0.tgz",
+      "integrity": "sha512-HHcfnApSZGtKhTiHqe8OZruOZe5XuFQH5/E0Yhj3u8fnFvzkM4/k6WjacUf4SvA0SPEAbfbgYmVPuo0VX/fIBQ==",
       "cpu": [
         "arm64"
       ],
@@ -1698,9 +1698,9 @@
       ]
     },
     "node_modules/@oxc-resolver/binding-wasm32-wasi": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-wasm32-wasi/-/binding-wasm32-wasi-11.19.1.tgz",
-      "integrity": "sha512-w8UCKhX826cP/ZLokXDS6+milN8y4X7zidsAttEdWlVoamTNf6lhBJldaWr3ukTDiye7s4HRcuPEPOXNC432Vg==",
+      "version": "11.20.0",
+      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-wasm32-wasi/-/binding-wasm32-wasi-11.20.0.tgz",
+      "integrity": "sha512-Tn0y1XOFYHNfK1wp1Z5QK8Rcld/bsOwRISQXfqAZ5IBpv8Gz1IvV39fUWNprqNdRizgcvFhOzWwFun2zkJsyBg==",
       "cpu": [
         "wasm32"
       ],
@@ -1708,32 +1708,43 @@
       "license": "MIT",
       "optional": true,
       "dependencies": {
-        "@napi-rs/wasm-runtime": "^1.1.1"
+        "@emnapi/core": "1.10.0",
+        "@emnapi/runtime": "1.10.0",
+        "@napi-rs/wasm-runtime": "^1.1.4"
       },
       "engines": {
         "node": ">=14.0.0"
       }
     },
-    "node_modules/@oxc-resolver/binding-win32-arm64-msvc": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-11.19.1.tgz",
-      "integrity": "sha512-nJ4AsUVZrVKwnU/QRdzPCCrO0TrabBqgJ8pJhXITdZGYOV28TIYystV1VFLbQ7DtAcaBHpocT5/ZJnF78YJPtQ==",
-      "cpu": [
-        "arm64"
-      ],
+    "node_modules/@oxc-resolver/binding-wasm32-wasi/node_modules/@emnapi/core": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.10.0.tgz",
+      "integrity": "sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==",
       "dev": true,
       "license": "MIT",
       "optional": true,
-      "os": [
-        "win32"
-      ]
+      "dependencies": {
+        "@emnapi/wasi-threads": "1.2.1",
+        "tslib": "^2.4.0"
+      }
     },
-    "node_modules/@oxc-resolver/binding-win32-ia32-msvc": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-win32-ia32-msvc/-/binding-win32-ia32-msvc-11.19.1.tgz",
-      "integrity": "sha512-EW+ND5q2Tl+a3pH81l1QbfgbF3HmqgwLfDfVithRFheac8OTcnbXt/JxqD2GbDkb7xYEqy1zNaVFRr3oeG8npA==",
+    "node_modules/@oxc-resolver/binding-wasm32-wasi/node_modules/@emnapi/runtime": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.10.0.tgz",
+      "integrity": "sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@oxc-resolver/binding-win32-arm64-msvc": {
+      "version": "11.20.0",
+      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-11.20.0.tgz",
+      "integrity": "sha512-qPi25YNPe4YenS8MgsQU2+bIFHxxpLx1LVna2444cEHqNPhNjvWf9zqj4aWE43H9LpAsTmkkAlA3eL5ElBU3mA==",
       "cpu": [
-        "ia32"
+        "arm64"
       ],
       "dev": true,
       "license": "MIT",
@@ -1743,9 +1754,9 @@
       ]
     },
     "node_modules/@oxc-resolver/binding-win32-x64-msvc": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-win32-x64-msvc/-/binding-win32-x64-msvc-11.19.1.tgz",
-      "integrity": "sha512-6hIU3RQu45B+VNTY4Ru8ppFwjVS/S5qwYyGhBotmjxfEKk41I2DlGtRfGJndZ5+6lneE2pwloqunlOyZuX/XAw==",
+      "version": "11.20.0",
+      "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-win32-x64-msvc/-/binding-win32-x64-msvc-11.20.0.tgz",
+      "integrity": "sha512-Wb14jWEW8huH6It9F6sXd9vrYmIS7pMrgkU6sxpLxkP+9z+wRgs71hUEhRpcn8FOXAFa27FVWfY2tRpbfTzfLw==",
       "cpu": [
         "x64"
       ],
@@ -2044,9 +2055,9 @@
       "license": "MIT"
     },
     "node_modules/@rollup/pluginutils": {
-      "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.3.0.tgz",
-      "integrity": "sha512-5EdhGZtnu3V88ces7s53hhfK5KSASnJZv8Lulpc04cWO3REESroJXg73DFsOmgbU2BhwV0E20bu2IDZb3VKW4Q==",
+      "version": "5.4.0",
+      "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.4.0.tgz",
+      "integrity": "sha512-MfPp06CjRLfXQ3wY0R8vJDYBy/MvVcc9OulEfR0B8Iv9ko+GCNaRZ+EpJYFl27LhKsZK0o420sYCRHCjfCgeUg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -2067,16 +2078,16 @@
       }
     },
     "node_modules/@storybook/addon-docs": {
-      "version": "10.4.1",
-      "resolved": "https://registry.npmjs.org/@storybook/addon-docs/-/addon-docs-10.4.1.tgz",
-      "integrity": "sha512-IYqUdjoZe4VO2LFZlKL/gwy7DsQSWCq6hX+zc1MBmZo04yycDASk1tte57n9pdlW3ajw9yYMF/+lVBi+xQjyvw==",
+      "version": "10.4.2",
+      "resolved": "https://registry.npmjs.org/@storybook/addon-docs/-/addon-docs-10.4.2.tgz",
+      "integrity": "sha512-CtW1O4xSKZPNtpWgpfp4yB/x4pj/of+3MvlEDfErSlr3Hp3QmEa2pCLaecR08H5LJqJFlt1PtG0UrIynTvgW9w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@mdx-js/react": "^3.0.0",
-        "@storybook/csf-plugin": "10.4.1",
+        "@storybook/csf-plugin": "10.4.2",
         "@storybook/icons": "^2.0.2",
-        "@storybook/react-dom-shim": "10.4.1",
+        "@storybook/react-dom-shim": "10.4.2",
         "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
         "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
         "ts-dedent": "^2.0.0"
@@ -2087,7 +2098,7 @@
       },
       "peerDependencies": {
         "@types/react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
-        "storybook": "^10.4.1"
+        "storybook": "^10.4.2"
       },
       "peerDependenciesMeta": {
         "@types/react": {
@@ -2096,13 +2107,13 @@
       }
     },
     "node_modules/@storybook/builder-vite": {
-      "version": "10.4.1",
-      "resolved": "https://registry.npmjs.org/@storybook/builder-vite/-/builder-vite-10.4.1.tgz",
-      "integrity": "sha512-/oyQrXoNOqN8SW5hNnYP+I1uvgFxKxWXj/EP6NXYzc5SQwImofgru+D2+6gDhL0+Q//+Hx05DJoQO2omvUJ8bQ==",
+      "version": "10.4.2",
+      "resolved": "https://registry.npmjs.org/@storybook/builder-vite/-/builder-vite-10.4.2.tgz",
+      "integrity": "sha512-d3+i9vbbUfV6hvT90qabmy1WmC4bEJ7iAYDm0217doeA+S6awF25GF0qOy9gN9waU4NMntHoVpdB1YQO2wUj/w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@storybook/csf-plugin": "10.4.1",
+        "@storybook/csf-plugin": "10.4.2",
         "ts-dedent": "^2.0.0"
       },
       "funding": {
@@ -2110,14 +2121,14 @@
         "url": "https://opencollective.com/storybook"
       },
       "peerDependencies": {
-        "storybook": "^10.4.1",
+        "storybook": "^10.4.2",
         "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"
       }
     },
     "node_modules/@storybook/csf-plugin": {
-      "version": "10.4.1",
-      "resolved": "https://registry.npmjs.org/@storybook/csf-plugin/-/csf-plugin-10.4.1.tgz",
-      "integrity": "sha512-WdPepGBxDGOUDjYd8KxMtcf+us/2PAcnBczl77XtrnxxHNs0jWesxKkiJ9yiuGrge4BPhDeAj6rxjbBoaHxLBA==",
+      "version": "10.4.2",
+      "resolved": "https://registry.npmjs.org/@storybook/csf-plugin/-/csf-plugin-10.4.2.tgz",
+      "integrity": "sha512-GqX/2DeF3/jKs5D7gpDiuT9gd0c/f2TKcnQ5av4/s3YqeN+0nhm7btkCrDfgF16uzE1Zj3OrkxvB3AOkfxWgDg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -2130,7 +2141,7 @@
       "peerDependencies": {
         "esbuild": "*",
         "rollup": "*",
-        "storybook": "^10.4.1",
+        "storybook": "^10.4.2",
         "vite": "*",
         "webpack": "*"
       },
@@ -2168,14 +2179,14 @@
       }
     },
     "node_modules/@storybook/react": {
-      "version": "10.4.1",
-      "resolved": "https://registry.npmjs.org/@storybook/react/-/react-10.4.1.tgz",
-      "integrity": "sha512-WuYz4NaUk4gmFAMliSpCbV8w6jP5OY9juBfw1huwzu2S/k5FhnVXwmrUaL0fmf3Bq/7NgkzmBBbZr6I6LuHayQ==",
+      "version": "10.4.2",
+      "resolved": "https://registry.npmjs.org/@storybook/react/-/react-10.4.2.tgz",
+      "integrity": "sha512-NfEH3CrdCAgUV4Z7SPN3Iw6nofcueqtRj8iHuo77GNjz0qSfuVi9iS7a8o7x7QFSeIBZwS0Jv3CgmhN8qvoLjg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@storybook/global": "^5.0.0",
-        "@storybook/react-dom-shim": "10.4.1",
+        "@storybook/react-dom-shim": "10.4.2",
         "react-docgen": "^8.0.2",
         "react-docgen-typescript": "^2.2.2"
       },
@@ -2188,7 +2199,7 @@
         "@types/react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
         "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
         "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
-        "storybook": "^10.4.1",
+        "storybook": "^10.4.2",
         "typescript": ">= 4.9.x"
       },
       "peerDependenciesMeta": {
@@ -2204,9 +2215,9 @@
       }
     },
     "node_modules/@storybook/react-dom-shim": {
-      "version": "10.4.1",
-      "resolved": "https://registry.npmjs.org/@storybook/react-dom-shim/-/react-dom-shim-10.4.1.tgz",
-      "integrity": "sha512-6QFqfDNH4DMrt7yHKRfpqRopsVUc/Az+sXIdJ39IetYnHUxL3nW4NVaPc6uy/8Qi8urzUyEXL/nn7cpSIP2aPQ==",
+      "version": "10.4.2",
+      "resolved": "https://registry.npmjs.org/@storybook/react-dom-shim/-/react-dom-shim-10.4.2.tgz",
+      "integrity": "sha512-Eng3Yt2NCjPX94QcfyLeUFhrMj0hec2yU9J/qafBVbfj9XrFI8o+0ZwYJ7uXb9ECbvPN4y06dgt/2W/LiR417w==",
       "dev": true,
       "license": "MIT",
       "funding": {
@@ -2218,7 +2229,7 @@
         "@types/react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
         "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
         "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
-        "storybook": "^10.4.1"
+        "storybook": "^10.4.2"
       },
       "peerDependenciesMeta": {
         "@types/react": {
@@ -2230,16 +2241,16 @@
       }
     },
     "node_modules/@storybook/react-vite": {
-      "version": "10.4.1",
-      "resolved": "https://registry.npmjs.org/@storybook/react-vite/-/react-vite-10.4.1.tgz",
-      "integrity": "sha512-zY6OzaXvXqBIUyc5ySE55/LAPQiF+o9ZyhQI978WMu4mY/fL7FpQ+ZVHRUCCgz/wTXtqE9jJwd/N10HI1kD0/Q==",
+      "version": "10.4.2",
+      "resolved": "https://registry.npmjs.org/@storybook/react-vite/-/react-vite-10.4.2.tgz",
+      "integrity": "sha512-nGrS74p0ujPSQ7qD5jKLLlao2igfTTb6Kf/uRhVV8XM0uM7WvxR9K20ddCM8jFmx1jY9fRm0UBGaeaXHDIh5SA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@joshwooding/vite-plugin-react-docgen-typescript": "^0.7.0",
         "@rollup/pluginutils": "^5.0.2",
-        "@storybook/builder-vite": "10.4.1",
-        "@storybook/react": "10.4.1",
+        "@storybook/builder-vite": "10.4.2",
+        "@storybook/react": "10.4.2",
         "empathic": "^2.0.0",
         "magic-string": "^0.30.0",
         "react-docgen": "^8.0.0",
@@ -2253,14 +2264,14 @@
       "peerDependencies": {
         "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
         "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
-        "storybook": "^10.4.1",
+        "storybook": "^10.4.2",
         "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"
       }
     },
     "node_modules/@swc/helpers": {
-      "version": "0.5.21",
-      "resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.21.tgz",
-      "integrity": "sha512-jI/VAmtdjB/RnI8GTnokyX7Ug8c+g+ffD6QRLa6XQewtnGyukKkKSk3wLTM3b5cjt1jNh9x0jfVlagdN2gDKQg==",
+      "version": "0.5.23",
+      "resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.23.tgz",
+      "integrity": "sha512-5lSsMOTXURePglDfvuAQUqkGek9Hg2kksOYay2m0+XR++b2NWYL/4sWyuvVBIs8oKnJaxkdi9whaL/sqN13afw==",
       "license": "Apache-2.0",
       "dependencies": {
         "tslib": "^2.8.0"
@@ -2625,12 +2636,12 @@
       }
     },
     "node_modules/@tanstack/react-virtual": {
-      "version": "3.13.26",
-      "resolved": "https://registry.npmjs.org/@tanstack/react-virtual/-/react-virtual-3.13.26.tgz",
-      "integrity": "sha512-DosdgjOxCLahkn0o+ilmZYwEjo1glfMGuRT/j3PQ18yr5XqA8N/BCaL9IJ3B5TRl+nnzyK2IOFgAILwzN3a9xQ==",
+      "version": "3.14.2",
+      "resolved": "https://registry.npmjs.org/@tanstack/react-virtual/-/react-virtual-3.14.2.tgz",
+      "integrity": "sha512-IpWnmCLvuymRfeeLNVXIzNEYBFLpd3drVIS91sqV78VTZFyldlChkOocZRCPp1B+Wnk09bcLNme8WaMU/9/9bQ==",
       "license": "MIT",
       "dependencies": {
-        "@tanstack/virtual-core": "3.16.0"
+        "@tanstack/virtual-core": "3.17.0"
       },
       "funding": {
         "type": "github",
@@ -2655,9 +2666,9 @@
       }
     },
     "node_modules/@tanstack/virtual-core": {
-      "version": "3.16.0",
-      "resolved": "https://registry.npmjs.org/@tanstack/virtual-core/-/virtual-core-3.16.0.tgz",
-      "integrity": "sha512-Er2N7q3WOiH6y2JLxsxNX+u2/sLqSsL0bxFgDjuiPiA7vKhZRm+IzcS17vRee3GNXr64UsesA5CAp9yTiIYw9A==",
+      "version": "3.17.0",
+      "resolved": "https://registry.npmjs.org/@tanstack/virtual-core/-/virtual-core-3.17.0.tgz",
+      "integrity": "sha512-gOxY/hFkPh/XQYhnThBHzkbkX3Ed+z/iushyz+R+JAr213aXxUDgQoTgTdrDpBSRsjFM73P/KfUyWmaF9WHMkQ==",
       "license": "MIT",
       "funding": {
         "type": "github",
@@ -2856,25 +2867,25 @@
       "license": "MIT"
     },
     "node_modules/@types/mdx": {
-      "version": "2.0.13",
-      "resolved": "https://registry.npmjs.org/@types/mdx/-/mdx-2.0.13.tgz",
-      "integrity": "sha512-+OWZQfAYyio6YkJb3HLxDrvnx6SWWDbC0zVPfBRzUk0/nqoDyf6dNxQi3eArPe8rJ473nobTMQ/8Zk+LxJ+Yuw==",
+      "version": "2.0.14",
+      "resolved": "https://registry.npmjs.org/@types/mdx/-/mdx-2.0.14.tgz",
+      "integrity": "sha512-T48PeuJtvLosNTPVhfnIp3i/n3a4g4Bad7YCq5k64D4u7NwDrAotikQ+5+sjtUvBmxCMlbo3dVL+C2dP0rWHzg==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/@types/node": {
-      "version": "24.12.4",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.12.4.tgz",
-      "integrity": "sha512-GUUEShf+PBCGW2KaXwcIt3Yk+e3pkKwWKb9GSyM9WQVE+ep2jzmHdGsHzu4wgcZy5fN9FBdVzjpBQsYlpfpgLA==",
+      "version": "24.13.1",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.13.1.tgz",
+      "integrity": "sha512-RSpUJGmvsJ1ZeBehQZFhIdpsz+bIpES0nIQXko4Ybq+N+kX6XvOq3Jo+iJ82FWLdblFq85AsMikd3m35jgezYg==",
       "license": "MIT",
       "dependencies": {
-        "undici-types": "~7.16.0"
+        "undici-types": "~7.18.0"
       }
     },
     "node_modules/@types/react": {
-      "version": "19.2.15",
-      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.15.tgz",
-      "integrity": "sha512-eRwcGNHve+E8qtEQSSRl6urh+rFop4v8gm6O8rGv25CodbvFdLjA1vVQ1KkiFE0w0UPOnb8tDiFKL5lp0rtY5Q==",
+      "version": "19.2.17",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.17.tgz",
+      "integrity": "sha512-MXfmqaVPEVgkBT/aY0aGCkRWWtByiYQXo3xdQ8r5RzuFrPiRn8Gar2tQdXSUQ2GKV3bkXckek89V8wQBY2Q/Aw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -2899,17 +2910,17 @@
       "license": "MIT"
     },
     "node_modules/@typescript-eslint/eslint-plugin": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.60.0.tgz",
-      "integrity": "sha512-QYb/sa74/s7OKMbACMjrYnGspj9Hs5YI5aaffSL65UfeBUzVzBJfVo3oWSpbzPurvm7yaCCo2Lk7lVj610HqKw==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.60.1.tgz",
+      "integrity": "sha512-JQ4S5GB0tfjO8BuJ4fcX+HodkzJjYBV+7OJ+wLygaX7OGQ7FudyHL4NSCA6ob+w3Yn+5MkKIozOwQhXeM7opVg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@eslint-community/regexpp": "^4.12.2",
-        "@typescript-eslint/scope-manager": "8.60.0",
-        "@typescript-eslint/type-utils": "8.60.0",
-        "@typescript-eslint/utils": "8.60.0",
-        "@typescript-eslint/visitor-keys": "8.60.0",
+        "@typescript-eslint/scope-manager": "8.60.1",
+        "@typescript-eslint/type-utils": "8.60.1",
+        "@typescript-eslint/utils": "8.60.1",
+        "@typescript-eslint/visitor-keys": "8.60.1",
         "ignore": "^7.0.5",
         "natural-compare": "^1.4.0",
         "ts-api-utils": "^2.5.0"
@@ -2922,7 +2933,7 @@
         "url": "https://opencollective.com/typescript-eslint"
       },
       "peerDependencies": {
-        "@typescript-eslint/parser": "^8.60.0",
+        "@typescript-eslint/parser": "^8.60.1",
         "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
         "typescript": ">=4.8.4 <6.1.0"
       }
@@ -2938,16 +2949,16 @@
       }
     },
     "node_modules/@typescript-eslint/parser": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.60.0.tgz",
-      "integrity": "sha512-fcqpj/MyK4sxDPcbe7STNPbpQL4RLZOPWuaTmwZYuc+hJKzRf58yRxfhqGpc6PIq9ZyfSBpfHgmUHmHs0KwHwg==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.60.1.tgz",
+      "integrity": "sha512-A0M6ua6H252bVjPvvtSgl2QA4+ET9S5Mtkb2GDyTxIhH/C4qDItT7RQNO5PhMC6NXGYXOR9dIalcDDgBKT7oFA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/scope-manager": "8.60.0",
-        "@typescript-eslint/types": "8.60.0",
-        "@typescript-eslint/typescript-estree": "8.60.0",
-        "@typescript-eslint/visitor-keys": "8.60.0",
+        "@typescript-eslint/scope-manager": "8.60.1",
+        "@typescript-eslint/types": "8.60.1",
+        "@typescript-eslint/typescript-estree": "8.60.1",
+        "@typescript-eslint/visitor-keys": "8.60.1",
         "debug": "^4.4.3"
       },
       "engines": {
@@ -2963,14 +2974,14 @@
       }
     },
     "node_modules/@typescript-eslint/project-service": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.60.0.tgz",
-      "integrity": "sha512-aZu74NNKJeUWqCjDddzdiKaS82dgYgV/vmf+Ui3ZdZejmgfXR/q+pRumgobnQ2cCJTgGTWp4ypiwsuofFubavg==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.60.1.tgz",
+      "integrity": "sha512-eXkTH2bxmXlqD1RnOPmLZ9ZM9D3VwSx04JOwBnP9RQ+yUA5a2Mu7SfW8uaV2Aon53NJzZlZYuX7tn91Izf+xaw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/tsconfig-utils": "^8.60.0",
-        "@typescript-eslint/types": "^8.60.0",
+        "@typescript-eslint/tsconfig-utils": "^8.60.1",
+        "@typescript-eslint/types": "^8.60.1",
         "debug": "^4.4.3"
       },
       "engines": {
@@ -2985,14 +2996,14 @@
       }
     },
     "node_modules/@typescript-eslint/scope-manager": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.60.0.tgz",
-      "integrity": "sha512-pFzqhllJMs+jghLQWzV00ds39xLzuyqPSev5pd8f4Ir0rtKR3ZLUB4/4dhjOFighWb9larvtfJvqL+4yKDI3Xw==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.60.1.tgz",
+      "integrity": "sha512-gvI5OQoptnxQnchOirukCuQ55svJSTuD/4k5+pC267xyBtYry748R9/c3tYUzb/iE6RZfllRz2lVulLCHkTm4w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.60.0",
-        "@typescript-eslint/visitor-keys": "8.60.0"
+        "@typescript-eslint/types": "8.60.1",
+        "@typescript-eslint/visitor-keys": "8.60.1"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -3003,9 +3014,9 @@
       }
     },
     "node_modules/@typescript-eslint/tsconfig-utils": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.60.0.tgz",
-      "integrity": "sha512-BZPR3RGYlAXnly6ymAxfkVn5rCbZzQNou0rxv3GfWZ8cTQp+hhVd73khbGLAd8k1TlAPLISH337M+tAgAnaJDQ==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.60.1.tgz",
+      "integrity": "sha512-nh8w4qAteiKuZu3pSSzG/yGKpw0OlkrKnzFmbVRenKaD4qc+7i1GrmZaLVkr8rk4uipiPGMOW4YsM6WmKZ5CvA==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -3020,15 +3031,15 @@
       }
     },
     "node_modules/@typescript-eslint/type-utils": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.60.0.tgz",
-      "integrity": "sha512-SX46wEUtitCpq7AN38HkUU/+zvUpdKf7ephtWAFgckH8O7PQIyL5gvrhQgBLuEYgLfuKWOVvWVskMbuFHAz5xg==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.60.1.tgz",
+      "integrity": "sha512-sdwTrpjosW7ANQYJ39ZBF1ZyEMEGVB2UsikrserVM/30a/F1dTLnu9bGxEdosugyu5caigjLrR2qiD11asjI1A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.60.0",
-        "@typescript-eslint/typescript-estree": "8.60.0",
-        "@typescript-eslint/utils": "8.60.0",
+        "@typescript-eslint/types": "8.60.1",
+        "@typescript-eslint/typescript-estree": "8.60.1",
+        "@typescript-eslint/utils": "8.60.1",
         "debug": "^4.4.3",
         "ts-api-utils": "^2.5.0"
       },
@@ -3045,9 +3056,9 @@
       }
     },
     "node_modules/@typescript-eslint/types": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.60.0.tgz",
-      "integrity": "sha512-AsE7x2XaAK+CVbeih0Fvbn+r1qHxtpLDJ3XUuFcIinT318T90yHMJC+Zgv+jUuDjQQd06HKwxnDu6sz1IcTilA==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.60.1.tgz",
+      "integrity": "sha512-4h0tY8ppCkdCzcrl2YM5M3my0xsE1Tf8om3owEu5oPWmXwkKRmk0j0LGDzYBGUcAlesEbxBhazqu/K4cu3Ug7w==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -3059,16 +3070,16 @@
       }
     },
     "node_modules/@typescript-eslint/typescript-estree": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.60.0.tgz",
-      "integrity": "sha512-3AcZNBGMClm6CXDyo8kYvVGT/sx29sS0oBsIb9oZI2gunA4Vm2M3YHzRLPvsUBBsl+yB5FPtltq7gGH0iTlp9g==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.60.1.tgz",
+      "integrity": "sha512-alpRkfG8hlVE5kdJW2GkfgDgXxold3e8e4l6EnmhRmRLbekgAPCCGDVD++sABy9FcgPFroq+uFcCSM1vR57Cew==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/project-service": "8.60.0",
-        "@typescript-eslint/tsconfig-utils": "8.60.0",
-        "@typescript-eslint/types": "8.60.0",
-        "@typescript-eslint/visitor-keys": "8.60.0",
+        "@typescript-eslint/project-service": "8.60.1",
+        "@typescript-eslint/tsconfig-utils": "8.60.1",
+        "@typescript-eslint/types": "8.60.1",
+        "@typescript-eslint/visitor-keys": "8.60.1",
         "debug": "^4.4.3",
         "minimatch": "^10.2.2",
         "semver": "^7.7.3",
@@ -3087,9 +3098,9 @@
       }
     },
     "node_modules/@typescript-eslint/typescript-estree/node_modules/semver": {
-      "version": "7.8.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.1.tgz",
-      "integrity": "sha512-rkVq3IXh+4FDGch+KwzX3aV9W3kO54GyEgpvBzSyctDA6Xtd7RJQV1xmXbeQp5v7+VzLOfVqiutSE6GICgPFvg==",
+      "version": "7.8.2",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.2.tgz",
+      "integrity": "sha512-c8jsqUZm3omBOI66G90z1Dyw5z622G8oLG+omfsHBJf3CWQTlOcwOjvOG6wtiNfW6anKm/eA39LMwMtMez2TiQ==",
       "dev": true,
       "license": "ISC",
       "bin": {
@@ -3100,16 +3111,16 @@
       }
     },
     "node_modules/@typescript-eslint/utils": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.60.0.tgz",
-      "integrity": "sha512-HtXuPfrHTyBDkameWpl+vJb1Uevu2tznAyahM1Oc4AENidCLTPiZDWIo4GfcxNdC/RcfGcadzzkqbRG87dUrQA==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.60.1.tgz",
+      "integrity": "sha512-h2MPBLoNtjc3qZWfY3Tl51yPorQ2McHn8pJfcMNTcIvrrZrr90Ykffit0yjrPFWQcRcUxzH20+6OcVdW4yHtUg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.9.1",
-        "@typescript-eslint/scope-manager": "8.60.0",
-        "@typescript-eslint/types": "8.60.0",
-        "@typescript-eslint/typescript-estree": "8.60.0"
+        "@typescript-eslint/scope-manager": "8.60.1",
+        "@typescript-eslint/types": "8.60.1",
+        "@typescript-eslint/typescript-estree": "8.60.1"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -3124,13 +3135,13 @@
       }
     },
     "node_modules/@typescript-eslint/visitor-keys": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.60.0.tgz",
-      "integrity": "sha512-9WI52t8ZGLVGrPMBet25yAftqY/n95+zmoUUtJBBQTKDSKUu7OsPTroT2op7U9JatkoRccL0YkWDNMFfC4Sjxg==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.60.1.tgz",
+      "integrity": "sha512-EbGRQg4FhrmwLodl+t3JNAnXHWVr9Vp+Zl1QBZVPY4ByfkzIT8cX3K6QWODHtkIZqqJVEWvhHSx3v5PDHsaQag==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.60.0",
+        "@typescript-eslint/types": "8.60.1",
         "eslint-visitor-keys": "^5.0.0"
       },
       "engines": {
@@ -3371,9 +3382,9 @@
       }
     },
     "node_modules/baseline-browser-mapping": {
-      "version": "2.10.32",
-      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.32.tgz",
-      "integrity": "sha512-wbPvpyjJPC0zdfdKXxqEL3Ea+bOMD/87X4lftiJkkaBiuG6ALQy1SLmEd7BSmVCuwCQsBrCamgBoLyfFDD1EPg==",
+      "version": "2.10.34",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.34.tgz",
+      "integrity": "sha512-IMDedajPifLnHNY0X9n8hKxRTQ6/eTHwr5bDo04WnuqxyKw6LYtQywCuuqPZwhl3aBXMvQpJov42GLCwRRdQzw==",
       "dev": true,
       "license": "Apache-2.0",
       "bin": {
@@ -3447,9 +3458,9 @@
       }
     },
     "node_modules/caniuse-lite": {
-      "version": "1.0.30001793",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001793.tgz",
-      "integrity": "sha512-iwSsYWaCOoh26cV8NwNRViHlrfUvYsHDfRVcbtmw0Kg6PJIZZXwMkj1442FYLBGkeUf1juAsU3DTfxW579mrPA==",
+      "version": "1.0.30001797",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001797.tgz",
+      "integrity": "sha512-l8xKG+gwAIExZGl9FrF7KUwuOmk6wbEPC9Xoy/RtnWv1XG0Q4LFlagaLpUv3Kiza3W/wm27zy0yWJEieYKAP6w==",
       "dev": true,
       "funding": [
         {
@@ -3746,9 +3757,9 @@
       "peer": true
     },
     "node_modules/electron-to-chromium": {
-      "version": "1.5.361",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.361.tgz",
-      "integrity": "sha512-Q6Hts7N9FnJc5LeGRINFvLhCI9xZmNtTDe5ZbcVezQz7cU4a8Aua3GH1b8J2XY8Al9PF+OCwYqhgsOOheMdvkA==",
+      "version": "1.5.368",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.368.tgz",
+      "integrity": "sha512-7RckJJK4uESJF9PxvfMWd3TGqIiieUTG4HxnKaKuIpGbcr+r2ZEB3g2gAhCP3Fqm42vJSzLfgab9eva/C4/XVw==",
       "dev": true,
       "license": "ISC"
     },
@@ -3763,9 +3774,9 @@
       }
     },
     "node_modules/enhanced-resolve": {
-      "version": "5.22.0",
-      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.22.0.tgz",
-      "integrity": "sha512-xYcDWrpELkFzz9SpZ3PlI6Eu6eD93Yf0WLDRxikGhWJ3MAir2SNZTIVCVZqZ/NUyx8AdMc2gT9C0gPiw18kG+A==",
+      "version": "5.23.0",
+      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.23.0.tgz",
+      "integrity": "sha512-yJN/BOOLxcOW2aQgeif9mSnaUB8KtvmMMp56oA1kx1CRfBKbhZm2pJ+NBY+3eOboHxix8lfjWpHE0Ei5U8RbSA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -3954,9 +3965,9 @@
       }
     },
     "node_modules/eslint-plugin-storybook": {
-      "version": "10.4.1",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-storybook/-/eslint-plugin-storybook-10.4.1.tgz",
-      "integrity": "sha512-sLEvd/7lg/LtXwMjj3iFxZtoeAC/8l1Qhuw3Noa8iF8i0UIgAejUs7k6DNSqHkwrPR8caWT4+3fxdMXs1iGLTg==",
+      "version": "10.4.2",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-storybook/-/eslint-plugin-storybook-10.4.2.tgz",
+      "integrity": "sha512-l3/vzLRmb8VSi3X1Bo6/Pa+64naw1jFsZE5jPPA4izvVdNhH1rF4rGuOC3kDTU926qKVBQtKua8D24XWQtvcGg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -3964,7 +3975,7 @@
       },
       "peerDependencies": {
         "eslint": ">=8",
-        "storybook": "^10.4.1"
+        "storybook": "^10.4.2"
       }
     },
     "node_modules/eslint-scope": {
@@ -4293,9 +4304,9 @@
       }
     },
     "node_modules/hasown": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.3.tgz",
-      "integrity": "sha512-ej4AhfhfL2Q2zpMmLo7U1Uv9+PyhIZpgQLGT1F9miIGmiCJIoCgSmczFdrc97mWT4kVY72KA+WnnhJ5pghSvSg==",
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
+      "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -4946,9 +4957,9 @@
       "license": "MIT"
     },
     "node_modules/node-releases": {
-      "version": "2.0.46",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.46.tgz",
-      "integrity": "sha512-GYVXHE2KnrzAfsAjl4uP++evGFCrAU1jta4ubEjIG7YWt/64Gqv66a30yKwWczVjA6j3bM4nBwH7Pk1JmDHaxQ==",
+      "version": "2.0.47",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.47.tgz",
+      "integrity": "sha512-Uzmd6LXpouKo8EUK68IjH4+E01w/hXyV3R3g/geCJo+rXLNfh1xucB+LOzYEOQPSiUK3h/xZf0cQGcSsmyL2Og==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -5031,35 +5042,34 @@
       }
     },
     "node_modules/oxc-resolver": {
-      "version": "11.19.1",
-      "resolved": "https://registry.npmjs.org/oxc-resolver/-/oxc-resolver-11.19.1.tgz",
-      "integrity": "sha512-qE/CIg/spwrTBFt5aKmwe3ifeDdLfA2NESN30E42X/lII5ClF8V7Wt6WIJhcGZjp0/Q+nQ+9vgxGk//xZNX2hg==",
+      "version": "11.20.0",
+      "resolved": "https://registry.npmjs.org/oxc-resolver/-/oxc-resolver-11.20.0.tgz",
+      "integrity": "sha512-CblytBiV/a/ZXY34dsVU2NxhIOxMXst8CvDCtyBelVITgd7PLrKzbEbA6oKLdPjvDKDzCiW48qzmzZ+mYaqn+g==",
       "dev": true,
       "license": "MIT",
       "funding": {
         "url": "https://github.com/sponsors/Boshen"
       },
       "optionalDependencies": {
-        "@oxc-resolver/binding-android-arm-eabi": "11.19.1",
-        "@oxc-resolver/binding-android-arm64": "11.19.1",
-        "@oxc-resolver/binding-darwin-arm64": "11.19.1",
-        "@oxc-resolver/binding-darwin-x64": "11.19.1",
-        "@oxc-resolver/binding-freebsd-x64": "11.19.1",
-        "@oxc-resolver/binding-linux-arm-gnueabihf": "11.19.1",
-        "@oxc-resolver/binding-linux-arm-musleabihf": "11.19.1",
-        "@oxc-resolver/binding-linux-arm64-gnu": "11.19.1",
-        "@oxc-resolver/binding-linux-arm64-musl": "11.19.1",
-        "@oxc-resolver/binding-linux-ppc64-gnu": "11.19.1",
-        "@oxc-resolver/binding-linux-riscv64-gnu": "11.19.1",
-        "@oxc-resolver/binding-linux-riscv64-musl": "11.19.1",
-        "@oxc-resolver/binding-linux-s390x-gnu": "11.19.1",
-        "@oxc-resolver/binding-linux-x64-gnu": "11.19.1",
-        "@oxc-resolver/binding-linux-x64-musl": "11.19.1",
-        "@oxc-resolver/binding-openharmony-arm64": "11.19.1",
-        "@oxc-resolver/binding-wasm32-wasi": "11.19.1",
-        "@oxc-resolver/binding-win32-arm64-msvc": "11.19.1",
-        "@oxc-resolver/binding-win32-ia32-msvc": "11.19.1",
-        "@oxc-resolver/binding-win32-x64-msvc": "11.19.1"
+        "@oxc-resolver/binding-android-arm-eabi": "11.20.0",
+        "@oxc-resolver/binding-android-arm64": "11.20.0",
+        "@oxc-resolver/binding-darwin-arm64": "11.20.0",
+        "@oxc-resolver/binding-darwin-x64": "11.20.0",
+        "@oxc-resolver/binding-freebsd-x64": "11.20.0",
+        "@oxc-resolver/binding-linux-arm-gnueabihf": "11.20.0",
+        "@oxc-resolver/binding-linux-arm-musleabihf": "11.20.0",
+        "@oxc-resolver/binding-linux-arm64-gnu": "11.20.0",
+        "@oxc-resolver/binding-linux-arm64-musl": "11.20.0",
+        "@oxc-resolver/binding-linux-ppc64-gnu": "11.20.0",
+        "@oxc-resolver/binding-linux-riscv64-gnu": "11.20.0",
+        "@oxc-resolver/binding-linux-riscv64-musl": "11.20.0",
+        "@oxc-resolver/binding-linux-s390x-gnu": "11.20.0",
+        "@oxc-resolver/binding-linux-x64-gnu": "11.20.0",
+        "@oxc-resolver/binding-linux-x64-musl": "11.20.0",
+        "@oxc-resolver/binding-openharmony-arm64": "11.20.0",
+        "@oxc-resolver/binding-wasm32-wasi": "11.20.0",
+        "@oxc-resolver/binding-win32-arm64-msvc": "11.20.0",
+        "@oxc-resolver/binding-win32-x64-msvc": "11.20.0"
       }
     },
     "node_modules/p-limit": {
@@ -5139,9 +5149,9 @@
       }
     },
     "node_modules/path-scurry/node_modules/lru-cache": {
-      "version": "11.5.0",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.0.tgz",
-      "integrity": "sha512-5YgH9UJd7wVb9hIouI2adWpgqrrICkt070Dnj8EUY1+B4B2P9eRLPAkAAo6NICA7CEhOIeBHl46u9zSNpNu7zA==",
+      "version": "11.5.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.1.tgz",
+      "integrity": "sha512-RPimw/7aMdv2oqRrxKwvZXcPfwBrn/JZ2xYcY9Hus/6LaS3VOAKVWKWgNLCFSiOm1ESXinjsDlidVU7JlnCN2A==",
       "dev": true,
       "license": "BlueOak-1.0.0",
       "engines": {
@@ -5274,9 +5284,9 @@
       }
     },
     "node_modules/react": {
-      "version": "19.2.6",
-      "resolved": "https://registry.npmjs.org/react/-/react-19.2.6.tgz",
-      "integrity": "sha512-sfWGGfavi0xr8Pg0sVsyHMAOziVYKgPLNrS7ig+ivMNb3wbCBw3KxtflsGBAwD3gYQlE/AEZsTLgToRrSCjb0Q==",
+      "version": "19.2.7",
+      "resolved": "https://registry.npmjs.org/react/-/react-19.2.7.tgz",
+      "integrity": "sha512-HNe9WslTbXmFK8o8cmwgAeJFSBvt1bPdHCVKtaaV+WlAN36mpT4hcRpwbf3fY56ar2oIXzsBpOAiIRHAdY0OlQ==",
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
@@ -5315,15 +5325,15 @@
       }
     },
     "node_modules/react-dom": {
-      "version": "19.2.6",
-      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.6.tgz",
-      "integrity": "sha512-0prMI+hvBbPjsWnxDLxlCGyM8PN6UuWjEUCYmZhO67xIV9Xasa/r/vDnq+Xyq4Lo27g8QSbO5YzARu0D1Sps3g==",
+      "version": "19.2.7",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.7.tgz",
+      "integrity": "sha512-t0BRVXvbiE/o20Hfw669rLbMCDWtYZLvmJigy2f0MxsXF+71pxhR3xOkspmsO8h3ZlNzyibAmtCa3l4lYKk6gQ==",
       "license": "MIT",
       "dependencies": {
         "scheduler": "^0.27.0"
       },
       "peerDependencies": {
-        "react": "^19.2.6"
+        "react": "^19.2.7"
       }
     },
     "node_modules/react-is": {
@@ -5517,9 +5527,9 @@
       }
     },
     "node_modules/storybook": {
-      "version": "10.4.1",
-      "resolved": "https://registry.npmjs.org/storybook/-/storybook-10.4.1.tgz",
-      "integrity": "sha512-V1Zd2e+gBFufqAQVZ1JR8KLqALsEZ3JYSBnWwQbKa6zCfWWanR6AFMyuOkLt2gZOgGp3h2Riuz88pGNVTQSG0A==",
+      "version": "10.4.2",
+      "resolved": "https://registry.npmjs.org/storybook/-/storybook-10.4.2.tgz",
+      "integrity": "sha512-5Ax5vbHxFgMBGGhQDm75Rrumm/HZC4ICFhMcJaM0UlqnC/4FKj/IaZtImZFupknyiiyUEcWHPQFA2kX3/VSv1A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -5564,9 +5574,9 @@
       }
     },
     "node_modules/storybook/node_modules/semver": {
-      "version": "7.8.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.1.tgz",
-      "integrity": "sha512-rkVq3IXh+4FDGch+KwzX3aV9W3kO54GyEgpvBzSyctDA6Xtd7RJQV1xmXbeQp5v7+VzLOfVqiutSE6GICgPFvg==",
+      "version": "7.8.2",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.2.tgz",
+      "integrity": "sha512-c8jsqUZm3omBOI66G90z1Dyw5z622G8oLG+omfsHBJf3CWQTlOcwOjvOG6wtiNfW6anKm/eA39LMwMtMez2TiQ==",
       "dev": true,
       "license": "ISC",
       "bin": {
@@ -5774,16 +5784,16 @@
       }
     },
     "node_modules/typescript-eslint": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.60.0.tgz",
-      "integrity": "sha512-9f65qWLZdAW9m1JaxBDUHcqRUfL8bkxxXL7XxEfI+F09q56PkBvIfCjLF3yInsDM/BBmwkqmCQdCZe/RYlIWEw==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.60.1.tgz",
+      "integrity": "sha512-6m5hkkRAp8lKvhVpcprAIn5KkehQEh+47oHH2VGnExEh7dhNxXlg6GPAOIu6TxbVQxhebrJDvjl3020ooiWCMA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/eslint-plugin": "8.60.0",
-        "@typescript-eslint/parser": "8.60.0",
-        "@typescript-eslint/typescript-estree": "8.60.0",
-        "@typescript-eslint/utils": "8.60.0"
+        "@typescript-eslint/eslint-plugin": "8.60.1",
+        "@typescript-eslint/parser": "8.60.1",
+        "@typescript-eslint/typescript-estree": "8.60.1",
+        "@typescript-eslint/utils": "8.60.1"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -5807,9 +5817,9 @@
       }
     },
     "node_modules/undici-types": {
-      "version": "7.16.0",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz",
-      "integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==",
+      "version": "7.18.2",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz",
+      "integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==",
       "license": "MIT"
     },
     "node_modules/unplugin": {
diff --git a/vortex/Cargo.toml b/vortex/Cargo.toml
index 982127a4035..adaca75632c 100644
--- a/vortex/Cargo.toml
+++ b/vortex/Cargo.toml
@@ -65,7 +65,6 @@ tokio = { workspace = true, features = ["full"] }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 vortex = { path = ".", features = ["tokio"] }
-vortex-bench = { workspace = true, features = ["unstable_encodings"] }
 vortex-tensor = { workspace = true }
 
 [features]
@@ -85,10 +84,6 @@ unstable_encodings = [
     "vortex-zstd?/unstable_encodings",
 ]
 
-[[example]]
-name = "turboquant_vector_search"
-required-features = ["files", "tokio", "unstable_encodings"]
-
 [[bench]]
 name = "single_encoding_throughput"
 harness = false
diff --git a/vortex/benches/common_encoding_tree_throughput.rs b/vortex/benches/common_encoding_tree_throughput.rs
index 552f66c321f..1507e0fb813 100644
--- a/vortex/benches/common_encoding_tree_throughput.rs
+++ b/vortex/benches/common_encoding_tree_throughput.rs
@@ -5,6 +5,7 @@
 
 use std::fmt;
 use std::ops::Deref;
+use std::sync::LazyLock;
 
 use divan::Bencher;
 #[cfg(not(codspeed))]
@@ -15,7 +16,6 @@ use rand::SeedableRng;
 use vortex::array::ArrayRef;
 use vortex::array::Canonical;
 use vortex::array::IntoArray;
-use vortex::array::LEGACY_SESSION;
 use vortex::array::VortexSessionExecute;
 use vortex::array::arrays::DictArray;
 use vortex::array::arrays::PrimitiveArray;
@@ -24,6 +24,7 @@ use vortex::array::arrays::VarBinArray;
 use vortex::array::arrays::VarBinViewArray;
 use vortex::array::arrays::varbin::VarBinArrayExt;
 use vortex::array::builtins::ArrayBuiltins;
+use vortex::array::session::ArraySession;
 use vortex::dtype::DType;
 use vortex::dtype::PType;
 use vortex::encodings::alp::ALP;
@@ -43,6 +44,7 @@ use vortex::encodings::runend::RunEnd;
 use vortex::encodings::runend::RunEndArrayExt;
 use vortex::error::VortexExpect;
 use vortex::extension::datetime::TimeUnit;
+use vortex_session::VortexSession;
 
 #[global_allocator]
 static GLOBAL: MiMalloc = MiMalloc;
@@ -51,6 +53,9 @@ fn main() {
     divan::main();
 }
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 const NUM_VALUES: u64 = 100_000;
 
 // Helper function to conditionally add counter based on codspeed cfg
@@ -72,7 +77,7 @@ mod setup {
     use super::*;
 
     fn setup_primitive_arrays() -> (PrimitiveArray, PrimitiveArray, PrimitiveArray) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let mut rng = StdRng::seed_from_u64(0);
         let uint_array =
             PrimitiveArray::from_iter((0..NUM_VALUES).map(|_| rng.random_range(42u32..256)));
@@ -95,7 +100,7 @@ mod setup {
 
     /// Create FoR <- BitPacked encoding tree for u64
     pub fn for_bp_u64() -> ArrayRef {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let (uint_array, ..) = setup_primitive_arrays();
         let compressed = FoR::encode(uint_array).unwrap();
         let inner = compressed.encoded();
@@ -107,7 +112,7 @@ mod setup {
 
     /// Create ALP <- FoR <- BitPacked encoding tree for f64
     pub fn alp_for_bp_f64() -> ArrayRef {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let (_, _, float_array) = setup_primitive_arrays();
         let alp_compressed = alp_encode(float_array.as_view(), None, &mut ctx).unwrap();
 
@@ -154,7 +159,7 @@ mod setup {
         let codes_prim = PrimitiveArray::from_iter(codes);
 
         // Compress codes with BitPacked (6 bits should be enough for ~50 unique values)
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let codes_bp = BitPacked::encode(&codes_prim.into_array(), 6, &mut ctx)
             .unwrap()
             .into_array();
@@ -185,7 +190,7 @@ mod setup {
             run_length -= 1;
         }
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let prim_array = PrimitiveArray::from_iter(values);
         let runend = RunEnd::encode(prim_array.into_array(), &mut ctx).unwrap();
 
@@ -234,7 +239,7 @@ mod setup {
             .collect();
 
         // Train and compress unique values with FSST
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let unique_varbinview = VarBinViewArray::from_iter_str(unique_strings);
         let fsst_compressor = fsst_train_compressor(&unique_varbinview);
         let fsst_values = fsst_compress(
@@ -273,7 +278,7 @@ mod setup {
             .collect();
 
         // Train and compress unique values with FSST
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let unique_varbinview = VarBinViewArray::from_iter_str(unique_strings);
         let fsst_compressor = fsst_train_compressor(&unique_varbinview);
         let fsst = fsst_compress(
@@ -341,7 +346,7 @@ mod setup {
         let temporal_array = TemporalArray::new_timestamp(ts_array, TimeUnit::Microseconds, None);
 
         // Split into days, seconds, subseconds
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = SESSION.create_execution_ctx();
         let parts = split_temporal(temporal_array.clone(), &mut ctx).unwrap();
 
         // Compress days with FoR <- BitPacked
@@ -454,6 +459,6 @@ fn decompress(bencher: Bencher, setup_fn: SetupFn) {
     let nbytes = compressed.nbytes();
 
     with_byte_counter(bencher, nbytes)
-        .with_inputs(|| (&compressed, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&compressed, SESSION.create_execution_ctx()))
         .bench_refs(|(a, ctx)| (**a).clone().execute::<Canonical>(ctx));
 }
diff --git a/vortex/benches/single_encoding_throughput.rs b/vortex/benches/single_encoding_throughput.rs
index 63e262fc210..2db4ebaf0ba 100644
--- a/vortex/benches/single_encoding_throughput.rs
+++ b/vortex/benches/single_encoding_throughput.rs
@@ -17,7 +17,6 @@ use rand::rngs::StdRng;
 use vortex::array::Canonical;
 use vortex::array::ExecutionCtx;
 use vortex::array::IntoArray;
-use vortex::array::LEGACY_SESSION;
 use vortex::array::arrays::PrimitiveArray;
 use vortex::array::arrays::VarBinViewArray;
 use vortex::array::builders::dict::dict_encode;
@@ -73,7 +72,7 @@ fn canonicalize(array: impl IntoArray, ctx: &mut ExecutionCtx) -> VortexResult<C
 
 // Setup functions
 fn setup_primitive_arrays() -> (PrimitiveArray, PrimitiveArray, PrimitiveArray) {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = SESSION.create_execution_ctx();
     let mut rng = StdRng::seed_from_u64(0);
     let uint_array =
         PrimitiveArray::from_iter((0..NUM_VALUES).map(|_| rng.random_range(42u32..256)));
@@ -148,18 +147,15 @@ fn bench_runend_compress_u32(bencher: Bencher) {
     let (uint_array, ..) = setup_primitive_arrays();
 
     with_byte_counter(bencher, NUM_VALUES * 4)
-        .with_inputs(|| (uint_array.clone(), LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (uint_array.clone(), SESSION.create_execution_ctx()))
         .bench_values(|(a, mut ctx)| RunEnd::encode(a.into_array(), &mut ctx).unwrap());
 }
 
 #[divan::bench(name = "runend_decompress_u32")]
 fn bench_runend_decompress_u32(bencher: Bencher) {
     let (uint_array, ..) = setup_primitive_arrays();
-    let compressed = RunEnd::encode(
-        uint_array.into_array(),
-        &mut LEGACY_SESSION.create_execution_ctx(),
-    )
-    .unwrap();
+    let compressed =
+        RunEnd::encode(uint_array.into_array(), &mut SESSION.create_execution_ctx()).unwrap();
 
     with_byte_counter(bencher, NUM_VALUES * 4)
         .with_inputs(|| (&compressed, SESSION.create_execution_ctx()))
@@ -215,14 +211,8 @@ fn bench_dict_compress_u32(bencher: Bencher) {
     let (uint_array, ..) = setup_primitive_arrays();
 
     with_byte_counter(bencher, NUM_VALUES * 4)
-        .with_inputs(|| &uint_array)
-        .bench_refs(|a| {
-            dict_encode(
-                &a.clone().into_array(),
-                &mut LEGACY_SESSION.create_execution_ctx(),
-            )
-            .unwrap()
-        });
+        .with_inputs(|| (&uint_array, SESSION.create_execution_ctx()))
+        .bench_refs(|(a, ctx)| dict_encode(&a.clone().into_array(), ctx).unwrap());
 }
 
 #[divan::bench(name = "dict_decompress_u32")]
@@ -230,7 +220,7 @@ fn bench_dict_decompress_u32(bencher: Bencher) {
     let (uint_array, ..) = setup_primitive_arrays();
     let compressed = dict_encode(
         &uint_array.into_array(),
-        &mut LEGACY_SESSION.create_execution_ctx(),
+        &mut SESSION.create_execution_ctx(),
     )
     .unwrap();
 
@@ -285,15 +275,8 @@ fn bench_alp_compress_f64(bencher: Bencher) {
     let (_, _, float_array) = setup_primitive_arrays();
 
     with_byte_counter(bencher, NUM_VALUES * 8)
-        .with_inputs(|| &float_array)
-        .bench_refs(|a| {
-            alp_encode(
-                a.as_view(),
-                None,
-                &mut LEGACY_SESSION.create_execution_ctx(),
-            )
-            .unwrap()
-        });
+        .with_inputs(|| (&float_array, SESSION.create_execution_ctx()))
+        .bench_refs(|(a, ctx)| alp_encode(a.as_view(), None, ctx).unwrap());
 }
 
 #[divan::bench(name = "alp_decompress_f64")]
@@ -302,7 +285,7 @@ fn bench_alp_decompress_f64(bencher: Bencher) {
     let compressed = alp_encode(
         float_array.as_view(),
         None,
-        &mut LEGACY_SESSION.create_execution_ctx(),
+        &mut SESSION.create_execution_ctx(),
     )
     .unwrap();
 
@@ -366,10 +349,8 @@ fn bench_zstd_compress_u32(bencher: Bencher) {
     let array = uint_array.into_array();
 
     with_byte_counter(bencher, NUM_VALUES * 4)
-        .with_inputs(|| array.clone())
-        .bench_values(|a| {
-            ZstdData::from_array(a, 3, 8192, &mut LEGACY_SESSION.create_execution_ctx()).unwrap()
-        });
+        .with_inputs(|| (array.clone(), SESSION.create_execution_ctx()))
+        .bench_values(|(a, mut ctx)| ZstdData::from_array(a, 3, 8192, &mut ctx).unwrap());
 }
 
 #[cfg(feature = "zstd")]
@@ -384,7 +365,7 @@ fn bench_zstd_decompress_u32(bencher: Bencher) {
             uint_array.into_array(),
             3,
             8192,
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut SESSION.create_execution_ctx(),
         )
         .unwrap(),
         validity,
@@ -405,14 +386,8 @@ fn bench_dict_compress_string(bencher: Bencher) {
     let nbytes = varbinview_arr.nbytes() as u64;
 
     with_byte_counter(bencher, nbytes)
-        .with_inputs(|| &varbinview_arr)
-        .bench_refs(|a| {
-            dict_encode(
-                &a.clone().into_array(),
-                &mut LEGACY_SESSION.create_execution_ctx(),
-            )
-            .unwrap()
-        });
+        .with_inputs(|| (&varbinview_arr, SESSION.create_execution_ctx()))
+        .bench_refs(|(a, ctx)| dict_encode(&a.clone().into_array(), ctx).unwrap());
 }
 
 #[divan::bench(name = "dict_decompress_string")]
@@ -421,7 +396,7 @@ fn bench_dict_decompress_string(bencher: Bencher) {
         VarBinViewArray::from_iter_str(gen_varbin_words(NUM_VALUES as usize, 0.00005));
     let dict = dict_encode(
         &varbinview_arr.clone().into_array(),
-        &mut LEGACY_SESSION.create_execution_ctx(),
+        &mut SESSION.create_execution_ctx(),
     )
     .unwrap();
     let nbytes = varbinview_arr.into_array().nbytes() as u64;
@@ -439,7 +414,7 @@ fn bench_fsst_compress_string(bencher: Bencher) {
     let nbytes = varbinview_arr.nbytes() as u64;
 
     with_byte_counter(bencher, nbytes)
-        .with_inputs(|| (&varbinview_arr, LEGACY_SESSION.create_execution_ctx()))
+        .with_inputs(|| (&varbinview_arr, SESSION.create_execution_ctx()))
         .bench_refs(|(a, ctx)| fsst_compress(*a, a.len(), a.dtype(), &fsst_compressor, ctx));
 }
 
@@ -453,7 +428,7 @@ fn bench_fsst_decompress_string(bencher: Bencher) {
         varbinview_arr.len(),
         varbinview_arr.dtype(),
         &fsst_compressor,
-        &mut LEGACY_SESSION.create_execution_ctx(),
+        &mut SESSION.create_execution_ctx(),
     );
     let nbytes = varbinview_arr.into_array().nbytes() as u64;
 
@@ -471,10 +446,8 @@ fn bench_zstd_compress_string(bencher: Bencher) {
     let array = varbinview_arr.into_array();
 
     with_byte_counter(bencher, nbytes)
-        .with_inputs(|| array.clone())
-        .bench_values(|a| {
-            ZstdData::from_array(a, 3, 8192, &mut LEGACY_SESSION.create_execution_ctx()).unwrap()
-        });
+        .with_inputs(|| (array.clone(), SESSION.create_execution_ctx()))
+        .bench_values(|(a, mut ctx)| ZstdData::from_array(a, 3, 8192, &mut ctx).unwrap());
 }
 
 #[cfg(feature = "zstd")]
@@ -490,7 +463,7 @@ fn bench_zstd_decompress_string(bencher: Bencher) {
             varbinview_arr.clone().into_array(),
             3,
             8192,
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut SESSION.create_execution_ctx(),
         )
         .unwrap(),
         validity,
@@ -503,136 +476,3 @@ fn bench_zstd_decompress_string(bencher: Bencher) {
         .with_inputs(|| (&compressed, SESSION.create_execution_ctx()))
         .bench_refs(|(a, ctx)| canonicalize((**a).clone(), ctx));
 }
-
-// TODO(connor): Remove this.
-// TurboQuant vector quantization benchmarks.
-#[cfg(feature = "unstable_encodings")]
-mod turboquant_benches {
-    use divan::Bencher;
-    use paste::paste;
-    use rand::SeedableRng;
-    use rand::rngs::StdRng;
-    use vortex::array::IntoArray;
-    use vortex::array::arrays::Extension;
-    use vortex::array::arrays::ExtensionArray;
-    use vortex::array::arrays::FixedSizeListArray;
-    use vortex::array::arrays::PrimitiveArray;
-    use vortex::array::arrays::scalar_fn::ScalarFnArrayExt;
-    use vortex::array::dtype::extension::ExtDType;
-    use vortex::array::extension::EmptyMetadata;
-    use vortex::array::validity::Validity;
-    use vortex_array::VortexSessionExecute;
-    use vortex_buffer::BufferMut;
-    use vortex_tensor::encodings::turboquant::TurboQuantConfig;
-    use vortex_tensor::encodings::turboquant::turboquant_encode_unchecked;
-    use vortex_tensor::scalar_fns::l2_denorm::normalize_as_l2_denorm;
-    use vortex_tensor::vector::Vector;
-
-    use super::SESSION;
-    use super::with_byte_counter;
-
-    const NUM_VECTORS: usize = 1_000;
-
-    /// Generate `num_vectors` random f32 Vector extension arrays of the given dimension
-    /// using i.i.d. standard normal components. This is a conservative test distribution:
-    /// real neural network embeddings typically have structure (clustered, anisotropic)
-    /// that the SRHT exploits for better quantization, so Gaussian i.i.d. is a
-    /// worst-case baseline for TurboQuant.
-    fn setup_vector_ext(dim: usize) -> ExtensionArray {
-        let mut rng = StdRng::seed_from_u64(42);
-        let normal = rand_distr::Normal::new(0.0f32, 1.0).unwrap();
-
-        let mut buf = BufferMut::<f32>::with_capacity(NUM_VECTORS * dim);
-        for _ in 0..(NUM_VECTORS * dim) {
-            buf.push(rand_distr::Distribution::sample(&normal, &mut rng));
-        }
-
-        let elements = PrimitiveArray::new::<f32>(buf.freeze(), Validity::NonNullable);
-        let fsl = FixedSizeListArray::try_new(
-            elements.into_array(),
-            dim as u32,
-            Validity::NonNullable,
-            NUM_VECTORS,
-        )
-        .unwrap();
-        let ext_dtype = ExtDType::<Vector>::try_new(EmptyMetadata, fsl.dtype().clone())
-            .unwrap()
-            .erased();
-        ExtensionArray::new(ext_dtype, fsl.into_array())
-    }
-
-    fn turboquant_config(bit_width: u8) -> TurboQuantConfig {
-        TurboQuantConfig {
-            bit_width,
-            seed: 123,
-            num_rounds: 3,
-        }
-    }
-
-    fn setup_normalized_vector_ext(dim: usize) -> ExtensionArray {
-        let ext = setup_vector_ext(dim);
-        let mut ctx = SESSION.create_execution_ctx();
-        let normalized = normalize_as_l2_denorm(ext.into_array(), &mut ctx)
-            .unwrap()
-            .child_at(0)
-            .clone();
-        normalized.execute::<ExtensionArray>(&mut ctx).unwrap()
-    }
-
-    macro_rules! turboquant_bench {
-        (compress, $dim:literal, $bits:literal, $name:ident) => {
-            paste! {
-                #[divan::bench(name = concat!("turboquant_encode_dim", stringify!($dim), "_", stringify!($bits), "bit"))]
-                fn $name(bencher: Bencher) {
-                    let normalized_ext = setup_normalized_vector_ext($dim);
-                    let config = turboquant_config($bits);
-                    with_byte_counter(bencher, (NUM_VECTORS * $dim * 4) as u64)
-                        .with_inputs(|| (normalized_ext.clone(), SESSION.create_execution_ctx()))
-                        .bench_refs(|(a, ctx)| {
-                            let normalized = a
-                                .as_ref()
-                                .as_opt::<Extension>()
-                                .expect("normalized benchmark input should be an Extension array");
-                            // SAFETY: Benchmark inputs are normalized once up front so the timed
-                            // region measures only TurboQuant encoding.
-                            unsafe { turboquant_encode_unchecked(normalized, &config, ctx) }
-                                .unwrap()
-                        });
-                }
-            }
-        };
-        (decompress, $dim:literal, $bits:literal, $name:ident) => {
-            paste! {
-                #[divan::bench(name = concat!("turboquant_decompress_dim", stringify!($dim), "_", stringify!($bits), "bit"))]
-                fn $name(bencher: Bencher) {
-                    let normalized_ext = setup_normalized_vector_ext($dim);
-                    let config = turboquant_config($bits);
-                    let mut ctx = SESSION.create_execution_ctx();
-                    let compressed = unsafe {
-                        turboquant_encode_unchecked(normalized_ext.as_view(), &config, &mut ctx)
-                    }
-                    .unwrap();
-                    with_byte_counter(bencher, (NUM_VECTORS * $dim * 4) as u64)
-                        .with_inputs(|| (&compressed, SESSION.create_execution_ctx()))
-                        .bench_refs(|(a, ctx)| {
-                            (**a).clone()
-                                .into_array()
-                                .execute::<ExtensionArray>(ctx)
-                                .unwrap()
-                        });
-                }
-            }
-        };
-    }
-
-    turboquant_bench!(compress, 128, 4, bench_tq_compress_128_4);
-    turboquant_bench!(decompress, 128, 4, bench_tq_decompress_128_4);
-    turboquant_bench!(compress, 768, 4, bench_tq_compress_768_4);
-    turboquant_bench!(decompress, 768, 4, bench_tq_decompress_768_4);
-    turboquant_bench!(compress, 1024, 2, bench_tq_compress_1024_2);
-    turboquant_bench!(decompress, 1024, 2, bench_tq_decompress_1024_2);
-    turboquant_bench!(compress, 1024, 4, bench_tq_compress_1024_4);
-    turboquant_bench!(decompress, 1024, 4, bench_tq_decompress_1024_4);
-    turboquant_bench!(compress, 1024, 8, bench_tq_compress_1024_8);
-    turboquant_bench!(decompress, 1024, 8, bench_tq_decompress_1024_8);
-}
diff --git a/vortex/examples/turboquant_vector_search.rs b/vortex/examples/turboquant_vector_search.rs
deleted file mode 100644
index 47e1e56ba3a..00000000000
--- a/vortex/examples/turboquant_vector_search.rs
+++ /dev/null
@@ -1,399 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! TurboQuant vector-search roundtrip on a vector-embedding dataset.
-//!
-//! Load a parquet dataset (cohere-small), wrap the `emb` column as a `Vector<f32, DIM>`
-//! extension, compress with BtrBlocks + TurboQuant, write to an in-memory Vortex file, then read
-//! the file back twice:
-//!
-//!   1. plain scan — decode to canonical `FixedSizeList<f32, DIM>` and verify the per-element diff
-//!      against the original. TurboQuant is lossy, so we only check the reconstructed values are
-//!      within a tolerance.
-//!   2. scan with a pushed-down cosine-similarity filter `cosine_similarity(emb, query) > thresh`.
-//!      The `CosineSimilarity` scalar fn is expressed directly as a filter `Expression`, so row
-//!      selection happens inside the scan rather than after materialization.
-//!
-//! The parquet file is cached under `vortex-bench/data/<dataset>/` after the first download. Run
-//! with:
-//!
-//! ```sh
-//! cargo run --example turboquant_vector_search \
-//!     -p vortex --features unstable_encodings --release
-//! ```
-
-use std::path::PathBuf;
-use std::time::Instant;
-
-use anyhow::Result;
-use anyhow::bail;
-use anyhow::ensure;
-use futures::TryStreamExt;
-use vortex::VortexSessionDefault;
-use vortex::array::ArrayRef;
-use vortex::array::IntoArray;
-use vortex::array::VortexSessionExecute;
-use vortex::array::arrays::ChunkedArray;
-use vortex::array::arrays::ExtensionArray;
-use vortex::array::arrays::FixedSizeListArray;
-use vortex::array::arrays::PrimitiveArray;
-use vortex::array::arrays::StructArray;
-use vortex::array::arrays::extension::ExtensionArrayExt;
-use vortex::array::arrays::fixed_size_list::FixedSizeListArrayExt;
-use vortex::array::arrays::struct_::StructArrayExt;
-use vortex::array::expr::col;
-use vortex::array::expr::gt;
-use vortex::array::expr::lit;
-use vortex::array::extension::EmptyMetadata;
-use vortex::array::scalar::Scalar;
-use vortex::array::scalar_fn::EmptyOptions;
-use vortex::array::scalar_fn::ScalarFnVTable;
-use vortex::array::scalar_fn::ScalarFnVTableExt;
-use vortex::buffer::ByteBuffer;
-use vortex::buffer::ByteBufferMut;
-use vortex::dtype::DType;
-use vortex::dtype::Nullability;
-use vortex::dtype::PType;
-use vortex::file::ALLOWED_ENCODINGS;
-use vortex::file::OpenOptionsSessionExt;
-use vortex::file::WriteOptionsSessionExt;
-use vortex::file::WriteStrategyBuilder;
-use vortex::io::session::RuntimeSessionExt;
-use vortex::session::VortexSession;
-use vortex_array::ExecutionCtx;
-use vortex_array::builtins::ArrayBuiltins;
-use vortex_bench::conversions::parquet_to_vortex_chunks;
-use vortex_bench::vector_dataset;
-use vortex_bench::vector_dataset::TrainLayout;
-use vortex_bench::vector_dataset::VectorDataset;
-use vortex_bench::vector_dataset::list_to_vector_ext;
-use vortex_btrblocks::BtrBlocksCompressorBuilder;
-use vortex_error::VortexExpect;
-use vortex_tensor::scalar_fns::cosine_similarity::CosineSimilarity;
-use vortex_tensor::scalar_fns::l2_denorm::L2Denorm;
-use vortex_tensor::scalar_fns::sorf_transform::SorfTransform;
-use vortex_tensor::vector::AnyVector;
-use vortex_tensor::vector::Vector;
-
-/// Cosine threshold for the demo filter. The query comes from the test split, so it may or may not
-/// have nearby rows in the train split.
-const COSINE_THRESHOLD: f32 = 0.85;
-
-/// Slack for checking decoded rows against a predicate that was evaluated on TurboQuant's lossy
-/// readthrough representation.
-const COSINE_THRESHOLD_TOL: f32 = 0.02;
-
-/// Regression ceiling on the decoded vs original max-abs-diff for 8-bit TurboQuant on 768-dim f32
-/// embeddings. Observed on cohere-small: ~0.10. Pinned with slack so the check catches large
-/// quality regressions without flapping on normal run-to-run variation.
-const MAX_ABS_DIFF_TOL: f32 = 0.2;
-
-#[tokio::main]
-async fn main() -> Result<()> {
-    // Opt in to registering the tensor scalar-fn array plugins before building the session.
-    // Without this, the TurboQuant-compressed `emb` column cannot be serialized into the Vortex
-    // file or deserialized on read.
-    //
-    // SAFETY: single-threaded setup before any other thread exists.
-    unsafe { std::env::set_var(vortex_tensor::SCALAR_FN_ARRAY_TENSOR_PLUGIN_ENV, "1") };
-
-    let session = VortexSession::default().with_tokio();
-    vortex_tensor::initialize(&session);
-    let mut ctx = session.create_execution_ctx();
-    println!("session initialized with tensor plugins");
-
-    let dataset = VectorDataset::CohereSmall100k; // This is one of the smaller datasets.
-
-    // Download the source parquet files.
-    let dataset_paths = vector_dataset::download(dataset, TrainLayout::Single).await?;
-    let (_id, query_vector) = get_query_vector(dataset_paths.test, &mut ctx).await?;
-    println!(
-        "query vector selected (id = {_id}, dim = {})",
-        query_vector.len()
-    );
-
-    // Bring the parquet file into memory so that we can write it as a vortex file (after prep).
-    let single_train_file = dataset_paths
-        .train_files
-        .first()
-        .vortex_expect("we know that there must be a file here")
-        .clone();
-
-    println!("reading parquet into chunked array...");
-    let chunked_table = parquet_to_vortex_chunks(single_train_file)
-        .await?
-        .into_array();
-    let len = chunked_table.len();
-    println!("parquet loaded: {len} rows");
-
-    let id = chunked_table.get_item("id")?;
-    let emb = chunked_table.get_item("emb")?;
-
-    println!("converting emb column to Vector extension type...");
-    let vector_array = list_to_vector_ext(emb)?;
-
-    let fields = [("id", id), ("emb", vector_array)];
-    let struct_array = StructArray::from_fields(&fields)?.into_array();
-
-    println!("compressing with TurboQuant and writing to in-memory Vortex file...");
-    let bytes = write_turboquant(&session, struct_array.clone().into_array()).await?;
-    println!("vortex file written: {} bytes", bytes.len());
-
-    println!("verifying roundtrip fidelity...");
-    verify_roundtrip(&session, &bytes, struct_array.clone()).await?;
-
-    println!("verifying filter pushdown with cosine similarity...");
-    verify_filter_pushdown(&session, &bytes, &query_vector, struct_array, &mut ctx).await?;
-
-    println!("all checks passed!");
-    Ok(())
-}
-
-async fn get_query_vector(
-    query_vectors_path: PathBuf,
-    ctx: &mut ExecutionCtx,
-) -> Result<(usize, Vec<f32>)> {
-    let test_vectors = parquet_to_vortex_chunks(query_vectors_path).await?;
-
-    // Get a random query vector.
-    let idx = rand::random_range(0..test_vectors.len());
-    let struct_scalar = test_vectors.execute_scalar(idx, ctx)?;
-    let id_scalar = struct_scalar
-        .as_struct()
-        .field("id")
-        .vortex_expect("test parquet file missing `id` field");
-
-    ensure!(
-        id_scalar
-            .as_primitive()
-            .as_::<i64>()
-            .vortex_expect("id was not a i64")
-            == idx as i64
-    );
-
-    let emb_scalar = struct_scalar
-        .as_struct()
-        .field("emb")
-        .vortex_expect("test parquet file missing `emb` field");
-
-    // Pack into a `Vec<f32>`.
-    let query_vector: Vec<f32> = emb_scalar
-        .as_list()
-        .elements()
-        .vortex_expect("somehow had a null test vector")
-        .iter()
-        .map(|element| {
-            element
-                .as_primitive()
-                .as_::<f32>()
-                .vortex_expect("value was not a f32")
-        })
-        .collect();
-
-    Ok((idx, query_vector))
-}
-
-async fn write_turboquant(session: &VortexSession, array: ArrayRef) -> Result<ByteBuffer> {
-    let compressor = BtrBlocksCompressorBuilder::default()
-        .with_turboquant()
-        .build();
-
-    // TurboQuant produces `L2Denorm(SorfTransform(FSL(Dict(...))), norms)`. The default write
-    // allow-list only covers canonical/compressed array encodings, so the tensor scalar-fn
-    // encodings it emits get rejected during normalization. Extend the set with the two encoding
-    // IDs this scheme actually uses.
-    let mut allowed = ALLOWED_ENCODINGS.clone();
-    allowed.insert(L2Denorm.id());
-    allowed.insert(SorfTransform.id());
-
-    let strategy = WriteStrategyBuilder::default()
-        .with_compressor(compressor)
-        .with_allow_encodings(allowed)
-        .build();
-
-    let mut buf = ByteBufferMut::empty();
-    session
-        .write_options()
-        .with_strategy(strategy)
-        .write(&mut buf, array.to_array_stream())
-        .await?;
-    Ok(buf.freeze())
-}
-
-async fn verify_roundtrip(
-    session: &VortexSession,
-    bytes: &ByteBuffer,
-    original: ArrayRef,
-) -> Result<()> {
-    let chunks: Vec<ArrayRef> = session
-        .open_options()
-        .open_buffer(bytes.clone())?
-        .scan()?
-        .into_array_stream()?
-        .try_collect()
-        .await?;
-
-    let mut ctx = session.create_execution_ctx();
-
-    let read: StructArray = ChunkedArray::try_new(chunks, original.dtype().clone())?
-        .into_array()
-        .execute(&mut ctx)?;
-    let original: StructArray = original.execute(&mut ctx)?;
-    ensure!(read.len() == original.len());
-
-    let read_emb = read.unmasked_field_by_name("emb")?.clone();
-    let original_emb = original.unmasked_field_by_name("emb")?.clone();
-
-    let decoded = flatten_vector_column(read_emb, &mut ctx)?;
-    let original_decoded = flatten_vector_column(original_emb, &mut ctx)?;
-
-    let (max_abs, mean_abs) = diff_stats(&original_decoded, &decoded);
-    println!(
-        "roundtrip fidelity: max_abs_diff = {max_abs:.6}, mean_abs_diff = {mean_abs:.6} \
-         (tol = {MAX_ABS_DIFF_TOL})"
-    );
-    if max_abs > MAX_ABS_DIFF_TOL {
-        bail!("TurboQuant max_abs_diff {max_abs} exceeds tolerance {MAX_ABS_DIFF_TOL}");
-    }
-
-    Ok(())
-}
-
-async fn verify_filter_pushdown(
-    session: &VortexSession,
-    bytes: &ByteBuffer,
-    query: &[f32],
-    original: ArrayRef,
-    ctx: &mut ExecutionCtx,
-) -> Result<()> {
-    // Build the filter as `cosine_similarity(emb, <query>) > threshold`. The RHS of
-    // `CosineSimilarity` is a `lit(...)` wrapping a `Vector<f32, DIM>` scalar; during scan
-    // evaluation the Literal expands to a ConstantArray whose row count matches the current batch,
-    // satisfying `CosineSimilarity`'s same-length requirement. The entire expression is pushed
-    // through `with_filter`, so row selection happens inside the scan rather than after the whole
-    // column is materialized.
-    println!("query: {}", preview_vector(query));
-
-    let query_scalar = build_query_vector_scalar(query)?;
-    let cosine_expr = CosineSimilarity.new_expr(EmptyOptions, [col("emb"), lit(query_scalar)]);
-    let filter = gt(cosine_expr, lit(COSINE_THRESHOLD));
-
-    let scan_start = Instant::now();
-    let chunks: Vec<ArrayRef> = session
-        .open_options()
-        .open_buffer(bytes.clone())?
-        .scan()?
-        .with_filter(filter)
-        .into_array_stream()?
-        .try_collect()
-        .await?;
-    let scan_ms = scan_start.elapsed().as_secs_f64() * 1e3;
-
-    let hits: usize = chunks.iter().map(|c| c.len()).sum();
-    println!(
-        "pushed down `cosine_similarity(emb, query) > {COSINE_THRESHOLD}`: {hits} rows survived \
-         in {scan_ms:.2} ms"
-    );
-    if hits == 0 {
-        println!("  no rows survived the filter for this random query");
-        return Ok(());
-    }
-
-    // Materialize the matching rows and dump each `emb` vector so the reader can see what the
-    // pushed-down filter actually selected. Vectors are truncated to the first few elements since
-    // DIM is typically large.
-    let filtered: StructArray = ChunkedArray::try_new(chunks, original.dtype().clone())?
-        .into_array()
-        .execute(ctx)?;
-
-    let emb = filtered.unmasked_field_by_name("emb")?.clone();
-    let flat = flatten_vector_column(emb, ctx)?;
-
-    let dim = query.len();
-    for (i, row) in flat.chunks_exact(dim).enumerate() {
-        let cos = cosine_similarity(query, row);
-        ensure!(
-            cos >= COSINE_THRESHOLD - COSINE_THRESHOLD_TOL,
-            "filtered row {i} had decoded cosine {cos:+.6}, below threshold {COSINE_THRESHOLD} \
-             by more than tolerance {COSINE_THRESHOLD_TOL}"
-        );
-        println!("  match {i}: cos = {cos:+.6} {}", preview_vector(row));
-    }
-
-    Ok(())
-}
-
-/// Plain `dot(a, b) / (||a|| * ||b||)` over two equal-length f32 slices. Used purely for reporting
-/// — the actual row selection is done inside the scan by the pushed-down `CosineSimilarity`
-/// expression. This lets the reader cross-check that the surviving rows really do clear the
-/// threshold once decoded.
-fn cosine_similarity(a: &[f32], b: &[f32]) -> f32 {
-    assert_eq!(a.len(), b.len());
-    let mut dot = 0.0f32;
-    let mut a_sq = 0.0f32;
-    let mut b_sq = 0.0f32;
-    for (&x, &y) in a.iter().zip(b) {
-        dot += x * y;
-        a_sq += x * x;
-        b_sq += y * y;
-    }
-    dot / (a_sq.sqrt() * b_sq.sqrt())
-}
-
-/// Render a vector as `[v0, v1, ..., vN-1, vN]` with the first 4 and last 1 elements at 4-decimal
-/// precision. Keeps the output compact for high-dim embeddings while still giving the reader
-/// something concrete to eyeball.
-fn preview_vector(row: &[f32]) -> String {
-    let dim = row.len();
-    if dim <= 5 {
-        return format!("[{}] (dim = {dim})", fmt_slice(row));
-    }
-    format!(
-        "[{}, ..., {}] (dim = {dim})",
-        fmt_slice(&row[..4]),
-        fmt_slice(&row[dim - 1..])
-    )
-}
-
-fn fmt_slice(s: &[f32]) -> String {
-    s.iter()
-        .map(|v| format!("{v:+.4}"))
-        .collect::<Vec<_>>()
-        .join(", ")
-}
-
-/// Wrap a query vector in a `Vector<f32, len>` extension scalar suitable for use as the RHS of a
-/// `CosineSimilarity` filter expression via `lit(...)`.
-fn build_query_vector_scalar(query: &[f32]) -> Result<Scalar> {
-    let element_dtype = DType::Primitive(PType::F32, Nullability::NonNullable);
-    let children: Vec<Scalar> = query
-        .iter()
-        .map(|&v| Scalar::primitive(v, Nullability::NonNullable))
-        .collect();
-    let fsl_scalar = Scalar::fixed_size_list(element_dtype, children, Nullability::NonNullable);
-    Ok(Scalar::extension::<Vector>(EmptyMetadata, fsl_scalar))
-}
-
-/// Decode a `Vector<f32, _>` extension array's storage down to its flat f32 buffer.
-fn flatten_vector_column(emb: ArrayRef, ctx: &mut ExecutionCtx) -> Result<Vec<f32>> {
-    let ext: ExtensionArray = emb.execute(ctx)?;
-    ensure!(ext.ext_dtype().is::<AnyVector>());
-
-    let fsl: FixedSizeListArray = ext.storage_array().clone().execute(ctx)?;
-    let elements: PrimitiveArray = fsl.elements().clone().execute(ctx)?;
-    Ok(elements.as_slice::<f32>().to_vec())
-}
-
-fn diff_stats(original: &[f32], decoded: &[f32]) -> (f32, f32) {
-    assert_eq!(original.len(), decoded.len());
-    let (sum_abs, max_abs) =
-        original
-            .iter()
-            .zip(decoded)
-            .fold((0.0f32, 0.0f32), |(sum, peak), (&orig, &dec)| {
-                let diff = (orig - dec).abs();
-                (sum + diff, peak.max(diff))
-            });
-    let mean_abs = sum_abs / original.len() as f32;
-    (max_abs, mean_abs)
-}
diff --git a/vortex/src/lib.rs b/vortex/src/lib.rs
index 8668de339cb..baf0d0ae761 100644
--- a/vortex/src/lib.rs
+++ b/vortex/src/lib.rs
@@ -12,6 +12,7 @@ use vortex_array::dtype::session::DTypeSession;
 // vortex::expr is in the process of having its dependencies inverted, and will eventually be
 // pulled back out into a vortex_expr crate.
 pub use vortex_array::expr;
+use vortex_array::memory::MemorySession;
 use vortex_array::optimizer::kernels::ArrayKernels;
 pub use vortex_array::scalar_fn;
 use vortex_array::scalar_fn::session::ScalarFnSession;
@@ -171,6 +172,7 @@ impl VortexSessionDefault for VortexSession {
             .with::<StatsSession>()
             .with::<ArrayKernels>()
             .with::<AggregateFnSession>()
+            .with::<MemorySession>()
             .with::<RuntimeSession>();
 
         #[cfg(feature = "files")]
@@ -343,11 +345,11 @@ mod test {
         let mut ctx = LEGACY_SESSION.create_execution_ctx();
 
         let recovered_primitive = recovered_array.execute::<PrimitiveArray>(&mut ctx)?;
-        assert!(
-            recovered_primitive
-                .validity()?
-                .mask_eq(&array.validity()?, &mut ctx)?
-        );
+        assert!(recovered_primitive.validity()?.mask_eq(
+            &array.validity()?,
+            array.len(),
+            &mut ctx
+        )?);
         assert_eq!(
             recovered_primitive.to_buffer::<u64>(),
             array.to_buffer::<u64>()